c2ec4b3fbc
* refs/heads/tmp-5da1114: Revert crypto changes from android-4.19.79-95 Revert "UPSTREAM: PM / wakeup updates" Revert "ANDROID: of: property: Enable of_devlink by default" Revert "UPSTREAM: dt-bindings: arm: coresight: Add support for coresight-loses-context-with-cpu" UPSTREAM: net: usbnet: Fix -Wcast-function-type UPSTREAM: USB: dummy-hcd: use usb_urb_dir_in instead of usb_pipein UPSTREAM: USB: dummy-hcd: increase max number of devices to 32 ANDROID: tty: serdev: Fix broken serial console input ANDROID: update kernel ABI (perf_event changes) BACKPORT: perf_event: Add support for LSM and SELinux checks UPSTREAM: iommu: Allow io-pgtable to be used outside of drivers/iommu/ ANDROID: update abi for 4.19.94 release ANDROID: update abi due to revert Revert "BACKPORT: perf_event: Add support for LSM and SELinux checks" UPSTREAM: selinux: sidtab reverse lookup hash table UPSTREAM: selinux: avoid atomic_t usage in sidtab UPSTREAM: selinux: check sidtab limit before adding a new entry UPSTREAM: selinux: fix context string corruption in convert_context() UPSTREAM: selinux: overhaul sidtab to fix bug and improve performance UPSTREAM: selinux: refactor mls_context_to_sid() and make it stricter UPSTREAM: selinux: use separate table for initial SID lookup UPSTREAM: selinux: make "selinux_policycap_names[]" const char * UPSTREAM: selinux: refactor sidtab conversion ANDROID: Update ABI representation ANDROID: GKI: clk: Don't disable unused clocks with sync state support ANDROID: GKI: clk: Add support for clock providers with sync state ANDROID: GKI: driver core: Add dev_has_sync_state() ANDROID: update kernel ABI representation BACKPORT: perf_event: Add support for LSM and SELinux checks ANDROID: update ABI representation UPSTREAM: exit: panic before exit_mm() on global init exit ANDROID: serdev: Fix platform device support ANDROID: Kconfig.gki: Add Hidden SPRD DRM configs ANDROID: gki_defconfig: Disable TRANSPARENT_HUGEPAGE ANDROID: gki_defconfig: Enable CONFIG_GNSS_CMDLINE_SERIAL ANDROID: gnss: Add command line test driver ANDROID: serdev: add platform device support ANDROID: gki_defconfig: enable ARM64_SW_TTBR0_PAN ANDROID: gki_defconfig: Set BINFMT_MISC as =m UPSTREAM: binder: fix incorrect calculation for num_valid ABI: Update ABI after f2fs merge ANDROID: add initial ABI whitelist for android-4.19 ANDROID: staging: android: ion: Fix build when CONFIG_ION_SYSTEM_HEAP=n ANDROID: staging: android: ion: Expose total heap and pool sizes via sysfs ANDROID: Update ABI representation due to vmstat counter changes UPSTREAM: include/linux/slab.h: fix sparse warning in kmalloc_type() UPSTREAM: mm, slab: shorten kmalloc cache names for large sizes UPSTREAM: mm, proc: add KReclaimable to /proc/meminfo UPSTREAM: mm: rename and change semantics of nr_indirectly_reclaimable_bytes UPSTREAM: dcache: allocate external names from reclaimable kmalloc caches UPSTREAM: mm, slab/slub: introduce kmalloc-reclaimable caches UPSTREAM: mm, slab: combine kmalloc_caches and kmalloc_dma_caches ANDROID: abi update for 4.19.89 ANDROID: update abi_gki_aarch64.xml for LTO, CFI, and SCS ANDROID: gki_defconfig: enable LTO, CFI, and SCS ANDROID: update abi_gki_aarch64.xml for CONFIG_GNSS ANDROID: cuttlefish_defconfig: Enable CONFIG_GNSS UPSTREAM: arm64: Validate tagged addresses in access_ok() called from kernel threads ANDROID: mm: Throttle rss_stat tracepoint UPSTREAM: mm: slub: really fix slab walking for init_on_free ANDROID: update abi_gki_aarch64.xml for nf change ANDROID: kbuild: limit LTO inlining ANDROID: kbuild: merge module sections with LTO ANDROID: netfilter: nf_nat: remove static from nf_nat_ipv4_fn UPSTREAM: drm/client: remove the exporting of drm_client_close ANDROID: f2fs: fix possible merge of unencrypted with encrypted I/O UPSTREAM: binder: Add binder_proc logging to binderfs UPSTREAM: binder: Make transaction_log available in binderfs UPSTREAM: binder: Add stats, state and transactions files UPSTREAM: binder: add a mount option to show global stats UPSTREAM: binder: Validate the default binderfs device names. UPSTREAM: binder: Add default binder devices through binderfs when configured UPSTREAM: binder: fix CONFIG_ANDROID_BINDER_DEVICES UPSTREAM: android: binder: use kstrdup instead of open-coding it UPSTREAM: binderfs: remove separate device_initcall() UPSTREAM: binderfs: respect limit on binder control creation UPSTREAM: binderfs: switch from d_add() to d_instantiate() UPSTREAM: binderfs: drop lock in binderfs_binder_ctl_create UPSTREAM: binderfs: kill_litter_super() before cleanup UPSTREAM: binderfs: rework binderfs_binder_device_create() UPSTREAM: binderfs: rework binderfs_fill_super() UPSTREAM: binderfs: prevent renaming the control dentry UPSTREAM: binderfs: remove outdated comment UPSTREAM: binderfs: fix error return code in binderfs_fill_super() UPSTREAM: binderfs: handle !CONFIG_IPC_NS builds UPSTREAM: binderfs: reserve devices for initial mount UPSTREAM: binderfs: rename header to binderfs.h UPSTREAM: binderfs: implement "max" mount option UPSTREAM: binderfs: make each binderfs mount a new instance UPSTREAM: binderfs: remove wrong kern_mount() call UPSTREAM: binder: implement binderfs UPSTREAM: binder: remove BINDER_DEBUG_ENTRY() ANDROID: Don't base allmodconfig on gki_defconfig ANDROID: Disable UNWINDER_ORC for allmodconfig ANDROID: update abi_gki_aarch64.xml for 4.19.87 BACKPORT: ARM: 8905/1: Emit __gnu_mcount_nc when using Clang 10.0.0 or newer ANDROID: update abi_gki_aarch64.xml ANDROID: gki_defconfig: =m's applied for virtio configs in arm64 UPSTREAM: of: property: Add device link support for interrupt-parent, dmas and -gpio(s) UPSTREAM: of: property: Add device link support for "iommu-map" UPSTREAM: of: property: Fix the semantics of of_is_ancestor_of() UPSTREAM: i2c: of: Populate fwnode in of_i2c_get_board_info() UPSTREAM: driver core: Clarify documentation for fwnode_operations.add_links() UPSTREAM: dt-bindings: arm: coresight: Add support for coresight-loses-context-with-cpu BACKPORT: coresight: etm4x: Save/restore state across CPU low power states ANDROID: Update ABI representation ANDROID: gki_defconfig: IIO=y f2fs: stop GC when the victim becomes fully valid f2fs: expose main_blkaddr in sysfs f2fs: choose hardlimit when softlimit is larger than hardlimit in f2fs_statfs_project() f2fs: Fix deadlock in f2fs_gc() context during atomic files handling f2fs: show f2fs instance in printk_ratelimited f2fs: fix potential overflow f2fs: fix to update dir's i_pino during cross_rename f2fs: support aligned pinned file f2fs: avoid kernel panic on corruption test f2fs: fix wrong description in document f2fs: cache global IPU bio f2fs: fix to avoid memory leakage in f2fs_listxattr f2fs: check total_segments from devices in raw_super f2fs: update multi-dev metadata in resize_fs f2fs: mark recovery flag correctly in read_raw_super_block() f2fs: fix to update time in lazytime mode vfs: don't allow writes to swap files mm: set S_SWAPFILE on blockdev swap devices BACKPORT: ARM: 8900/1: UNWINDER_FRAME_POINTER implementation for Clang ANDROID: update abi_gki_aarch64.xml for 4.19.87 ANDROID: gki_defconfig: FW_CACHE to no FROMGIT: firmware_class: make firmware caching configurable FROMLIST: arm64: implement Shadow Call Stack FROMLIST: arm64: disable SCS for hypervisor code BACKPORT: FROMLIST: arm64: vdso: disable Shadow Call Stack FROMLIST: arm64: efi: restore x18 if it was corrupted FROMLIST: arm64: preserve x18 when CPU is suspended FROMLIST: arm64: reserve x18 from general allocation with SCS FROMLIST: arm64: disable function graph tracing with SCS FROMLIST: scs: add support for stack usage debugging FROMLIST: scs: add accounting FROMLIST: add support for Clang's Shadow Call Stack (SCS) FROMLIST: arm64: kernel: avoid x18 in __cpu_soft_restart FROMLIST: arm64: kvm: stop treating register x18 as caller save FROMLIST: arm64/lib: copy_page: avoid x18 register in assembler code FROMLIST: arm64: mm: avoid x18 in idmap_kpti_install_ng_mappings ANDROID: use non-canonical CFI jump tables ANDROID: arm64: add __nocfi to __apply_alternatives ANDROID: arm64: add __pa_function ANDROID: arm64: allow ThinLTO to be selected ANDROID: soc/tegra: disable ARCH_TEGRA_210_SOC with LTO FROMLIST: arm64: fix alternatives with LLVM's integrated assembler ANDROID: irqchip/gic-v3: rename gic_of_init to work around a ThinLTO+CFI bug ANDROID: init: ensure initcall ordering with LTO Revert "ANDROID: init: ensure initcall ordering with LTO" ANDROID: add support for ThinLTO ANDROID: clang: update to 10.0.1 ANDROID: gki_defconfig: enable CONFIG_REGULATOR_FIXED_VOLTAGE ANDROID: gki_defconfig: removed CONFIG_PM_WAKELOCKS ANDROID: gki_defconfig: enable CONFIG_IKHEADERS as m FROMGIT: pinctrl: devicetree: Avoid taking direct reference to device name string ANDROID: update abi_gki_aarch64.xml for 4.19.86 update ANDROID: Update ABI representation ANDROID: gki_defconfig: disable FUNCTION_TRACER ANDROID: Update the ABI representation ANDROID: update ABI representation ANDROID: add unstripped modules to the distribution FROMLIST: vsprintf: Inline call to ptr_to_hashval UPSTREAM: rss_stat: Add support to detect RSS updates of external mm UPSTREAM: mm: emit tracepoint when RSS changes FROMGIT: driver core: Allow device link operations inside sync_state() ANDROID: uid_sys_stats: avoid double accounting of dying threads ANDROID: scsi: ufs-qcom: Enable BROKEN_CRYPTO quirk flag ANDROID: scsi: ufs-hisi: Enable BROKEN_CRYPTO quirk flag ANDROID: scsi: ufs: Add quirk bit for controllers that don't play well with inline crypto ANDROID: scsi: ufs: UFS init should not require inline crypto ANDROID: scsi: ufs: UFS crypto variant operations API ANDROID: gki_defconfig: enable inline encryption BACKPORT: FROMLIST: ext4: add inline encryption support BACKPORT: FROMLIST: f2fs: add inline encryption support BACKPORT: FROMLIST: fscrypt: add inline encryption support BACKPORT: FROMLIST: scsi: ufs: Add inline encryption support to UFS BACKPORT: FROMLIST: scsi: ufs: UFS crypto API BACKPORT: FROMLIST: scsi: ufs: UFS driver v2.1 spec crypto additions BACKPORT: FROMLIST: block: blk-crypto for Inline Encryption ANDROID: block: Fix bio_crypt_should_process WARN_ON BACKPORT: FROMLIST: block: Add encryption context to struct bio BACKPORT: FROMLIST: block: Keyslot Manager for Inline Encryption FROMLIST: f2fs: add support for IV_INO_LBLK_64 encryption policies FROMLIST: ext4: add support for IV_INO_LBLK_64 encryption policies BACKPORT: FROMLIST: fscrypt: add support for IV_INO_LBLK_64 policies FROMLIST: fscrypt: zeroize fscrypt_info before freeing FROMLIST: fscrypt: remove struct fscrypt_ctx BACKPORT: FROMLIST: fscrypt: invoke crypto API for ESSIV handling ANDROID: build kernels with llvm-nm and llvm-objcopy ANDROID: Fix allmodconfig build with CC=clang UPSTREAM: mm/page_poison: expose page_poisoning_enabled to kernel modules FROMGIT: of: property: Add device link support for iommus, mboxes and io-channels FROMGIT: of: property: Make it easy to add device links from DT properties FROMGIT: of: property: Minor style clean up of of_link_to_phandle() Revert "ANDROID: of/property: Add device link support for iommus" ANDROID: Add allmodconfig build.configs for x86_64 and aarch64 ANDROID: fix allmodconfig build ANDROID: nf: IDLETIMER: Fix possible use before initialization in idletimer_resume BACKPORT: coresight: funnel: Support static funnel BACKPORT:FROMGIT: coresight: replicator: Fix missing spin_lock_init() BACKPORT:FROMGIT: coresight: funnel: Fix missing spin_lock_init() BACKPORT:FROMGIT: coresight: Serialize enabling/disabling a link device. UPSTREAM: coresight: tmc-etr: Add barrier packets when moving offset forward UPSTREAM: coresight: tmc-etr: Decouple buffer sync and barrier packet insertion UPSTREAM: coresight: tmc: Make memory width mask computation into a function UPSTREAM: coresight: tmc-etr: Fix perf_data check UPSTREAM: coresight: tmc-etr: Fix updating buffer in not-snapshot mode. UPSTREAM: coresight: tmc-etr: Check if non-secure access is enabled UPSTREAM: coresight: tmc-etr: Handle memory errors BACKPORT: coresight: etr_buf: Consolidate refcount initialization UPSTREAM: coresight: Fix DEBUG_LOCKS_WARN_ON for uninitialized attribute UPSTREAM: coresight: Use coresight device names for sinks in PMU attribute UPSTREAM: coresight: tmc-etr: alloc_perf_buf: Do not call smp_processor_id from preemptible UPSTREAM: coresight: tmc-etr: Do not call smp_processor_id() from preemptible UPSTREAM: coresight: perf: Don't set the truncated flag in snapshot mode UPSTREAM: coresight: tmc-etf: Fix snapshot mode update function UPSTREAM: coresight: tmc-etr: Properly set AUX buffer head in snapshot mode UPSTREAM: coresight: tmc-etr: Add support for CPU-wide trace scenarios UPSTREAM: coresight: tmc-etr: Allocate and free ETR memory buffers for CPU-wide scenarios UPSTREAM: coresight: tmc-etr: Introduce the notion of IDR to ETR devices UPSTREAM: coresight: tmc-etr: Introduce the notion of reference counting to ETR devices UPSTREAM: coresight: tmc-etr: Introduce the notion of process ID to ETR devices UPSTREAM: coresight: tmc-etr: Create per-thread buffer allocation function UPSTREAM: coresight: tmc-etr: Refactor function tmc_etr_setup_perf_buf() UPSTREAM: coresight: Communicate perf event to sink buffer allocation functions UPSTREAM: coresight: perf: Refactor function free_event_data() UPSTREAM: coresight: perf: Clean up function etm_setup_aux() UPSTREAM: coresight: Properly address concurrency in sink::update() functions UPSTREAM: coresight: Properly address errors in sink::disable() functions UPSTREAM: coresight: Move reference counting inside sink drivers UPSTREAM: coresight: Adding return code to sink::disable() operation UPSTREAM: coresight: etm4x: Configure tracers to emit timestamps UPSTREAM: coresight: etm4x: Skip selector pair 0 UPSTREAM: coresight: etm4x: Add kernel configuration for CONTEXTID UPSTREAM: coresight: pmu: Adding ITRACE property to cs_etm PMU UPSTREAM: coresight: tmc: Cleanup power management UPSTREAM: coresight: Fix freeing up the coresight connections UPSTREAM: coresight: tmc: Report DMA setup failures UPSTREAM: coresight: catu: fix clang build warning UPSTREAM: perf/core: Fix the address filtering fix UPSTREAM: perf, pt, coresight: Fix address filters for vmas with non-zero offset UPSTREAM: perf: Copy parent's address filter offsets on clone UPSTREAM: coresight: Use event attributes for sink selection UPSTREAM: coresight: perf: Add "sinks" group to PMU directory UPSTREAM: coresight: etb10: Add support for CLAIM tag UPSTREAM: coreisght: tmc: Claim device before use UPSTREAM: coresight: dynamic-replicator: Claim device for use UPSTREAM: coresight: funnel: Claim devices before use UPSTREAM: coresight: etmx: Claim devices before use UPSTREAM: coresight: Add support for CLAIM tag protocol UPSTREAM: coresight: dynamic-replicator: Handle multiple connections UPSTREAM: coresight: etb10: Handle errors enabling the device UPSTREAM: coresight: etm3: Add support for handling errors UPSTREAM: coresight: etm4x: Add support for handling errors UPSTREAM: coresight: tmc-etb/etf: Prepare to handle errors enabling UPSTREAM: coresight: tmc-etr: Handle errors enabling CATU UPSTREAM: coresight: tmc-etr: Refactor for handling errors UPSTREAM: coresight: Handle failures in enabling a trace path UPSTREAM: coresight: tmc: Fix byte-address alignment for RRP UPSTREAM: coresight: etm4x: Configure EL2 exception level when kernel is running in HYP UPSTREAM: coresight: etb10: Splitting function etb_enable() UPSTREAM: coresight: etb10: Refactor etb_drvdata::mode handling UPSTREAM: coresight: etm-perf: Add support for ETR backend UPSTREAM: coresight: perf: Remove set_buffer call back UPSTREAM: coresight: perf: Add helper to retrieve sink configuration UPSTREAM: coresight: perf: Remove reset_buffer call back for sinks UPSTREAM: coresight: Convert driver messages to dev_dbg UPSTREAM: coresight: tmc-etr: Relax collection of trace from sysfs mode UPSTREAM: coresight: tmc-etr: Handle driver mode specific ETR buffers UPSTREAM: coresight: perf: Disable trace path upon source error UPSTREAM: coresight: perf: Allow tracing on hotplugged CPUs UPSTREAM: coresight: perf: Avoid unncessary CPU hotplug read lock UPSTREAM: coresight: perf: Fix per cpu path management UPSTREAM: coresight: Fix handling of sinks UPSTREAM: coresight: Use ERR_CAST instead of ERR_PTR UPSTREAM: coresight: Fix remote endpoint parsing UPSTREAM: coresight: platform: Fix leaking device reference UPSTREAM: coresight: platform: Fix refcounting for graph nodes UPSTREAM: coresight: platform: Refactor graph endpoint parsing UPSTREAM: coresight: Document error handling in coresight_register ANDROID: regression introduced override_creds=off ANDROID: overlayfs: internal getxattr operations without sepolicy checking ANDROID: overlayfs: add __get xattr method ANDROID: Add optional __get xattr method paired to __vfs_getxattr UPSTREAM: scsi: ufs: override auto suspend tunables for ufs UPSTREAM: scsi: core: allow auto suspend override by low-level driver FROMGIT: of: property: Skip adding device links to suppliers that aren't devices ANDROID: gki_defconfig: enable CONFIG_KEYBOARD_GPIO UPSTREAM: dm bufio: introduce a global cache replacement UPSTREAM: dm bufio: remove old-style buffer cleanup UPSTREAM: dm bufio: introduce a global queue UPSTREAM: dm bufio: refactor adjust_total_allocated UPSTREAM: dm bufio: call adjust_total_allocated from __link_buffer and __unlink_buffer ANDROID: dummy_cpufreq: Implement get() ANDROID: gki_defconfig: enable CONFIG_CPUSETS ANDROID: virtio: virtio_input: Set the amount of multitouch slots in virtio input rtlwifi: Fix potential overflow on P2P code ANDROID: cpufreq: create dummy cpufreq driver ANDROID: Allow DRM_IOCTL_MODE_*_DUMB for render clients. Cuttlefish Wifi: Add data ops in virt_wifi driver for scan data simulation ANDROID: of: property: Enable of_devlink by default ANDROID: of: property: Make sure child dependencies don't block probing of parent ANDROID: driver core: Allow fwnode_operations.add_links to differentiate errors ANDROID: driver core: Allow a device to wait on optional suppliers ANDROID: driver core: Add device link support for SYNC_STATE_ONLY flag FROMGIT: docs: driver-model: Add documentation for sync_state FROMGIT: driver: core: Improve documentation for fwnode_operations.add_links() FROMGIT: of: property: Minor code formatting/style clean ups ANDROID: of/property: Add device link support for iommus ANDROID: move up spin_unlock_bh() ahead of remove_proc_entry() BACKPORT: arm64: tags: Preserve tags for addresses translated via TTBR1 UPSTREAM: arm64: memory: Implement __tag_set() as common function UPSTREAM: arm64/mm: fix variable 'tag' set but not used UPSTREAM: arm64: avoid clang warning about self-assignment ANDROID: sdcardfs: evict dentries on fscrypt key removal ANDROID: fscrypt: add key removal notifier chain ANDROID: refactor build.config files to remove duplication ANDROID: Move from clang r353983c to r365631c ANDROID: gki_defconfig: remove PWRSEQ_EMMC and PWRSEQ_SIMPLE ANDROID: unconditionally compile sig_ok in struct module ANDROID: gki_defconfig: enable fs-verity UPSTREAM: mm: vmalloc: show number of vmalloc pages in /proc/meminfo BACKPORT: PM/sleep: Expose suspend stats in sysfs UPSTREAM: power: supply: Init device wakeup after device_add() UPSTREAM: PM / wakeup: Unexport wakeup_source_sysfs_{add,remove}() UPSTREAM: PM / wakeup: Register wakeup class kobj after device is added UPSTREAM: PM / wakeup: Fix sysfs registration error path UPSTREAM: PM / wakeup: Show wakeup sources stats in sysfs UPSTREAM: PM / wakeup: Use wakeup_source_register() in wakelock.c UPSTREAM: PM / wakeup: Drop wakeup_source_init(), wakeup_source_prepare() UPSTREAM: PM / wakeup: Drop wakeup_source_drop() UPSTREAM: PM / core: Add support to skip power management in device/driver model gki_defconfig: Enable CONFIG_DM_SNAPSHOT ANDROID: gki_defconfig: enable accelerated AES and SHA-256 ANDROID: fix overflow in /proc/uid_cputime/remove_uid_range ANDROID: kasan: fix has_attribute check on older GCC versions ANDROID: gki_defconfig: enable CONFIG_PARAVIRT and CONFIG_HYPERVISOR_GUEST ANDROID: gki_defconfig: enable CONFIG_NLS_* ANDROID: gki_defconfig: Enable BPF_JIT and BPF_JIT_ALWAYS_ON FROMGIT: of: property: Create device links for all child-supplier depencencies FROMGIT: of/platform: Pause/resume sync state during init and of_platform_populate() BACKPORT: FROMGIT: driver core: Add sync_state driver/bus callback BACKPORT: FROMGIT: of: property: Add functional dependency link from DT bindings FROMGIT: driver core: Add support for linking devices during device addition FROMGIT: driver core: Add fwnode_to_dev() to look up device from fwnode UPSTREAM: mm: untag user pointers in mmap/munmap/mremap/brk UPSTREAM: vfio/type1: untag user pointers in vaddr_get_pfn UPSTREAM: tee/shm: untag user pointers in tee_shm_register UPSTREAM: media/v4l2-core: untag user pointers in videobuf_dma_contig_user_get UPSTREAM: drm/radeon: untag user pointers in radeon_gem_userptr_ioctl BACKPORT: drm/amdgpu: untag user pointers UPSTREAM: userfaultfd: untag user pointers UPSTREAM: fs/namespace: untag user pointers in copy_mount_options UPSTREAM: mm: untag user pointers in get_vaddr_frames UPSTREAM: mm: untag user pointers in mm/gup.c UPSTREAM: mm: untag user pointers passed to memory syscalls BACKPORT: lib: untag user pointers in strn*_user UPSTREAM: arm64: Fix reference to docs for ARM64_TAGGED_ADDR_ABI UPSTREAM: selftests, arm64: add kernel headers path for tags_test BACKPORT: arm64: Relax Documentation/arm64/tagged-pointers.rst UPSTREAM: arm64: Define Documentation/arm64/tagged-address-abi.rst UPSTREAM: arm64: Change the tagged_addr sysctl control semantics to only prevent the opt-in UPSTREAM: arm64: Tighten the PR_{SET, GET}_TAGGED_ADDR_CTRL prctl() unused arguments UPSTREAM: selftests, arm64: fix uninitialized symbol in tags_test.c UPSTREAM: arm64: mm: Really fix sparse warning in untagged_addr() UPSTREAM: selftests, arm64: add a selftest for passing tagged pointers to kernel BACKPORT: arm64: Introduce prctl() options to control the tagged user addresses ABI UPSTREAM: arm64: untag user pointers in access_ok and __uaccess_mask_ptr UPSTREAM: uaccess: add noop untagged_addr definition BACKPORT: block: annotate refault stalls from IO submission f2fs: add a condition to detect overflow in f2fs_ioc_gc_range() f2fs: fix to add missing F2FS_IO_ALIGNED() condition f2fs: fix to fallback to buffered IO in IO aligned mode f2fs: fix to handle error path correctly in f2fs_map_blocks f2fs: fix extent corrupotion during directIO in LFS mode f2fs: check all the data segments against all node ones f2fs: Add a small clarification to CONFIG_FS_F2FS_FS_SECURITY f2fs: fix inode rwsem regression f2fs: fix to avoid accessing uninitialized field of inode page in is_alive() f2fs: avoid infinite GC loop due to stale atomic files f2fs: Fix indefinite loop in f2fs_gc() f2fs: convert inline_data in prior to i_size_write f2fs: fix error path of f2fs_convert_inline_page() f2fs: add missing documents of reserve_root/resuid/resgid f2fs: fix flushing node pages when checkpoint is disabled f2fs: enhance f2fs_is_checkpoint_ready()'s readability f2fs: clean up __bio_alloc()'s parameter f2fs: fix wrong error injection path in inc_valid_block_count() f2fs: fix to writeout dirty inode during node flush f2fs: optimize case-insensitive lookups f2fs: introduce f2fs_match_name() for cleanup f2fs: Fix indefinite loop in f2fs_gc() f2fs: allocate memory in batch in build_sit_info() f2fs: support FS_IOC_{GET,SET}FSLABEL f2fs: fix to avoid data corruption by forbidding SSR overwrite f2fs: Fix build error while CONFIG_NLS=m Revert "f2fs: avoid out-of-range memory access" f2fs: cleanup the code in build_sit_entries. f2fs: fix wrong available node count calculation f2fs: remove duplicate code in f2fs_file_write_iter f2fs: fix to migrate blocks correctly during defragment f2fs: use wrapped f2fs_cp_error() f2fs: fix to use more generic EOPNOTSUPP f2fs: use wrapped IS_SWAPFILE() f2fs: Support case-insensitive file name lookups f2fs: include charset encoding information in the superblock fs: Reserve flag for casefolding f2fs: fix to avoid call kvfree under spinlock fs: f2fs: Remove unnecessary checks of SM_I(sbi) in update_general_status() f2fs: disallow direct IO in atomic write f2fs: fix to handle quota_{on,off} correctly f2fs: fix to detect cp error in f2fs_setxattr() f2fs: fix to spread f2fs_is_checkpoint_ready() f2fs: support fiemap() for directory inode f2fs: fix to avoid discard command leak f2fs: fix to avoid tagging SBI_QUOTA_NEED_REPAIR incorrectly f2fs: fix to drop meta/node pages during umount f2fs: disallow switching io_bits option during remount f2fs: fix panic of IO alignment feature f2fs: introduce {page,io}_is_mergeable() for readability f2fs: fix livelock in swapfile writes f2fs: add fs-verity support ext4: update on-disk format documentation for fs-verity ext4: add fs-verity read support ext4: add basic fs-verity support fs-verity: support builtin file signatures fs-verity: add SHA-512 support fs-verity: implement FS_IOC_MEASURE_VERITY ioctl fs-verity: implement FS_IOC_ENABLE_VERITY ioctl fs-verity: add data verification hooks for ->readpages() fs-verity: add the hook for file ->setattr() fs-verity: add the hook for file ->open() fs-verity: add inode and superblock fields fs-verity: add Kconfig and the helper functions for hashing fs: uapi: define verity bit for FS_IOC_GETFLAGS fs-verity: add UAPI header fs-verity: add MAINTAINERS file entry fs-verity: add a documentation file ext4: fix kernel oops caused by spurious casefold flag ext4: fix coverity warning on error path of filename setup ext4: optimize case-insensitive lookups ext4: fix dcache lookup of !casefolded directories unicode: update to Unicode 12.1.0 final unicode: add missing check for an error return from utf8lookup() ext4: export /sys/fs/ext4/feature/casefold if Unicode support is present unicode: refactor the rule for regenerating utf8data.h ext4: Support case-insensitive file name lookups ext4: include charset encoding information in the superblock unicode: update unicode database unicode version 12.1.0 unicode: introduce test module for normalized utf8 implementation unicode: implement higher level API for string handling unicode: reduce the size of utf8data[] unicode: introduce code for UTF-8 normalization unicode: introduce UTF-8 character database ext4 crypto: fix to check feature status before get policy fscrypt: document the new ioctls and policy version ubifs: wire up new fscrypt ioctls f2fs: wire up new fscrypt ioctls ext4: wire up new fscrypt ioctls fscrypt: require that key be added when setting a v2 encryption policy fscrypt: add FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS ioctl fscrypt: allow unprivileged users to add/remove keys for v2 policies fscrypt: v2 encryption policy support fscrypt: add an HKDF-SHA512 implementation fscrypt: add FS_IOC_GET_ENCRYPTION_KEY_STATUS ioctl fscrypt: add FS_IOC_REMOVE_ENCRYPTION_KEY ioctl fscrypt: add FS_IOC_ADD_ENCRYPTION_KEY ioctl fscrypt: rename keyinfo.c to keysetup.c fscrypt: move v1 policy key setup to keysetup_v1.c fscrypt: refactor key setup code in preparation for v2 policies fscrypt: rename fscrypt_master_key to fscrypt_direct_key fscrypt: add ->ci_inode to fscrypt_info fscrypt: use FSCRYPT_* definitions, not FS_* fscrypt: use FSCRYPT_ prefix for uapi constants fs, fscrypt: move uapi definitions to new header <linux/fscrypt.h> fscrypt: use ENOPKG when crypto API support missing fscrypt: improve warnings for missing crypto API support fscrypt: improve warning messages for unsupported encryption contexts fscrypt: make fscrypt_msg() take inode instead of super_block fscrypt: clean up base64 encoding/decoding fscrypt: remove loadable module related code Updated following files to fix build errors: drivers/gpu/msm/kgsl_pool.c drivers/hwtracing/coresight/coresight-dummy.c drivers/iommu/dma-mapping-fast.c drivers/iommu/io-pgtable-fast.c drivers/iommu/io-pgtable-msm-secure.c kernel/taskstats.c mm/vmalloc.c security/selinux/ss/sidtab.h Conflicts: arch/arm/Makefile arch/arm64/Kconfig arch/x86/include/asm/syscall_wrapper.h build.config.common drivers/clk/clk.c drivers/hwtracing/coresight/coresight-etm-perf.c drivers/hwtracing/coresight/coresight-funnel.c drivers/hwtracing/coresight/coresight-tmc-etf.c drivers/hwtracing/coresight/coresight-tmc-etr.c drivers/hwtracing/coresight/coresight-tmc.c drivers/hwtracing/coresight/coresight-tmc.h drivers/hwtracing/coresight/coresight.c drivers/hwtracing/coresight/of_coresight.c drivers/iommu/arm-smmu.c drivers/iommu/io-pgtable-arm.c drivers/iommu/io-pgtable.c drivers/scsi/scsi_sysfs.c drivers/scsi/sd.c drivers/scsi/ufs/ufshcd.c drivers/scsi/ufs/ufshcd.h drivers/staging/android/ion/ion.c drivers/staging/android/ion/ion.h drivers/staging/android/ion/ion_page_pool.c fs/ext4/readpage.c fs/f2fs/data.c fs/f2fs/f2fs.h fs/f2fs/file.c fs/f2fs/segment.c fs/f2fs/super.c include/linux/clk-provider.h include/linux/compiler_types.h include/linux/coresight.h include/linux/mmzone.h include/scsi/scsi_device.h include/trace/events/kmem.h kernel/events/core.c kernel/sched/core.c mm/vmstat.c Change-Id: I2eca52b08b484f2b5c30437671cab8cb0195b8d6 Signed-off-by: Ivaylo Georgiev <irgeorgiev@codeaurora.org>
1043 lines
24 KiB
C
1043 lines
24 KiB
C
/*
|
|
* taskstats.c - Export per-task statistics to userland
|
|
*
|
|
* Copyright (C) Shailabh Nagar, IBM Corp. 2006
|
|
* (C) Balbir Singh, IBM Corp. 2006
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/taskstats_kern.h>
|
|
#include <linux/tsacct_kern.h>
|
|
#include <linux/delayacct.h>
|
|
#include <linux/cpumask.h>
|
|
#include <linux/percpu.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/swap.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/cgroupstats.h>
|
|
#include <linux/sysstats.h>
|
|
#include <linux/cgroup.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/file.h>
|
|
#include <linux/pid_namespace.h>
|
|
#include <net/genetlink.h>
|
|
#include <linux/atomic.h>
|
|
#include <linux/sched/cputime.h>
|
|
#include <linux/oom.h>
|
|
|
|
/*
|
|
* Maximum length of a cpumask that can be specified in
|
|
* the TASKSTATS_CMD_ATTR_REGISTER/DEREGISTER_CPUMASK attribute
|
|
*/
|
|
#define TASKSTATS_CPUMASK_MAXLEN (100+6*NR_CPUS)
|
|
|
|
static DEFINE_PER_CPU(__u32, taskstats_seqnum);
|
|
static int family_registered;
|
|
struct kmem_cache *taskstats_cache;
|
|
|
|
static struct genl_family family;
|
|
|
|
static const struct nla_policy taskstats_cmd_get_policy[TASKSTATS_CMD_ATTR_MAX+1] = {
|
|
[TASKSTATS_CMD_ATTR_PID] = { .type = NLA_U32 },
|
|
[TASKSTATS_CMD_ATTR_TGID] = { .type = NLA_U32 },
|
|
[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK] = { .type = NLA_STRING },
|
|
[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK] = { .type = NLA_STRING },
|
|
[TASKSTATS_CMD_ATTR_FOREACH] = { .type = NLA_U32 },};
|
|
|
|
/*
|
|
* We have to use TASKSTATS_CMD_ATTR_MAX here, it is the maxattr in the family.
|
|
* Make sure they are always aligned.
|
|
*/
|
|
static const struct nla_policy cgroupstats_cmd_get_policy[TASKSTATS_CMD_ATTR_MAX+1] = {
|
|
[CGROUPSTATS_CMD_ATTR_FD] = { .type = NLA_U32 },
|
|
};
|
|
|
|
static const struct nla_policy
|
|
sysstats_cmd_get_policy[TASKSTATS_CMD_ATTR_MAX+1] = {
|
|
[SYSSTATS_CMD_ATTR_SYSMEM_STATS] = { .type = NLA_U32 },
|
|
};
|
|
|
|
struct listener {
|
|
struct list_head list;
|
|
pid_t pid;
|
|
char valid;
|
|
};
|
|
|
|
struct listener_list {
|
|
struct rw_semaphore sem;
|
|
struct list_head list;
|
|
};
|
|
static DEFINE_PER_CPU(struct listener_list, listener_array);
|
|
|
|
struct tgid_iter {
|
|
unsigned int tgid;
|
|
struct task_struct *task;
|
|
};
|
|
|
|
enum actions {
|
|
REGISTER,
|
|
DEREGISTER,
|
|
CPU_DONT_CARE
|
|
};
|
|
|
|
static int prepare_reply(struct genl_info *info, u8 cmd, struct sk_buff **skbp,
|
|
size_t size)
|
|
{
|
|
struct sk_buff *skb;
|
|
void *reply;
|
|
|
|
/*
|
|
* If new attributes are added, please revisit this allocation
|
|
*/
|
|
skb = genlmsg_new(size, GFP_KERNEL);
|
|
if (!skb)
|
|
return -ENOMEM;
|
|
|
|
if (!info) {
|
|
int seq = this_cpu_inc_return(taskstats_seqnum) - 1;
|
|
|
|
reply = genlmsg_put(skb, 0, seq, &family, 0, cmd);
|
|
} else
|
|
reply = genlmsg_put_reply(skb, info, &family, 0, cmd);
|
|
if (reply == NULL) {
|
|
nlmsg_free(skb);
|
|
return -EINVAL;
|
|
}
|
|
|
|
*skbp = skb;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Send taskstats data in @skb to listener with nl_pid @pid
|
|
*/
|
|
static int send_reply(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
struct genlmsghdr *genlhdr = nlmsg_data(nlmsg_hdr(skb));
|
|
void *reply = genlmsg_data(genlhdr);
|
|
|
|
genlmsg_end(skb, reply);
|
|
|
|
return genlmsg_reply(skb, info);
|
|
}
|
|
|
|
/*
|
|
* Send taskstats data in @skb to listeners registered for @cpu's exit data
|
|
*/
|
|
static void send_cpu_listeners(struct sk_buff *skb,
|
|
struct listener_list *listeners)
|
|
{
|
|
struct genlmsghdr *genlhdr = nlmsg_data(nlmsg_hdr(skb));
|
|
struct listener *s, *tmp;
|
|
struct sk_buff *skb_next, *skb_cur = skb;
|
|
void *reply = genlmsg_data(genlhdr);
|
|
int rc, delcount = 0;
|
|
|
|
genlmsg_end(skb, reply);
|
|
|
|
rc = 0;
|
|
down_read(&listeners->sem);
|
|
list_for_each_entry(s, &listeners->list, list) {
|
|
skb_next = NULL;
|
|
if (!list_is_last(&s->list, &listeners->list)) {
|
|
skb_next = skb_clone(skb_cur, GFP_KERNEL);
|
|
if (!skb_next)
|
|
break;
|
|
}
|
|
rc = genlmsg_unicast(&init_net, skb_cur, s->pid);
|
|
if (rc == -ECONNREFUSED) {
|
|
s->valid = 0;
|
|
delcount++;
|
|
}
|
|
skb_cur = skb_next;
|
|
}
|
|
up_read(&listeners->sem);
|
|
|
|
if (skb_cur)
|
|
nlmsg_free(skb_cur);
|
|
|
|
if (!delcount)
|
|
return;
|
|
|
|
/* Delete invalidated entries */
|
|
down_write(&listeners->sem);
|
|
list_for_each_entry_safe(s, tmp, &listeners->list, list) {
|
|
if (!s->valid) {
|
|
list_del(&s->list);
|
|
kfree(s);
|
|
}
|
|
}
|
|
up_write(&listeners->sem);
|
|
}
|
|
|
|
static void fill_stats(struct user_namespace *user_ns,
|
|
struct pid_namespace *pid_ns,
|
|
struct task_struct *tsk, struct taskstats *stats)
|
|
{
|
|
memset(stats, 0, sizeof(*stats));
|
|
/*
|
|
* Each accounting subsystem adds calls to its functions to
|
|
* fill in relevant parts of struct taskstsats as follows
|
|
*
|
|
* per-task-foo(stats, tsk);
|
|
*/
|
|
|
|
delayacct_add_tsk(stats, tsk);
|
|
|
|
/* fill in basic acct fields */
|
|
stats->version = TASKSTATS_VERSION;
|
|
stats->nvcsw = tsk->nvcsw;
|
|
stats->nivcsw = tsk->nivcsw;
|
|
bacct_add_tsk(user_ns, pid_ns, stats, tsk);
|
|
|
|
/* fill in extended acct fields */
|
|
xacct_add_tsk(stats, tsk);
|
|
}
|
|
|
|
static int fill_stats_for_pid(pid_t pid, struct taskstats *stats)
|
|
{
|
|
struct task_struct *tsk;
|
|
|
|
tsk = find_get_task_by_vpid(pid);
|
|
if (!tsk)
|
|
return -ESRCH;
|
|
fill_stats(current_user_ns(), task_active_pid_ns(current), tsk, stats);
|
|
put_task_struct(tsk);
|
|
return 0;
|
|
}
|
|
|
|
static int fill_stats_for_tgid(pid_t tgid, struct taskstats *stats)
|
|
{
|
|
struct task_struct *tsk, *first;
|
|
unsigned long flags;
|
|
int rc = -ESRCH;
|
|
u64 delta, utime, stime;
|
|
u64 start_time;
|
|
|
|
/*
|
|
* Add additional stats from live tasks except zombie thread group
|
|
* leaders who are already counted with the dead tasks
|
|
*/
|
|
rcu_read_lock();
|
|
first = find_task_by_vpid(tgid);
|
|
|
|
if (!first || !lock_task_sighand(first, &flags))
|
|
goto out;
|
|
|
|
if (first->signal->stats)
|
|
memcpy(stats, first->signal->stats, sizeof(*stats));
|
|
else
|
|
memset(stats, 0, sizeof(*stats));
|
|
|
|
tsk = first;
|
|
start_time = ktime_get_ns();
|
|
do {
|
|
if (tsk->exit_state)
|
|
continue;
|
|
/*
|
|
* Accounting subsystem can call its functions here to
|
|
* fill in relevant parts of struct taskstsats as follows
|
|
*
|
|
* per-task-foo(stats, tsk);
|
|
*/
|
|
delayacct_add_tsk(stats, tsk);
|
|
|
|
/* calculate task elapsed time in nsec */
|
|
delta = start_time - tsk->start_time;
|
|
/* Convert to micro seconds */
|
|
do_div(delta, NSEC_PER_USEC);
|
|
stats->ac_etime += delta;
|
|
|
|
task_cputime(tsk, &utime, &stime);
|
|
stats->ac_utime += div_u64(utime, NSEC_PER_USEC);
|
|
stats->ac_stime += div_u64(stime, NSEC_PER_USEC);
|
|
|
|
stats->nvcsw += tsk->nvcsw;
|
|
stats->nivcsw += tsk->nivcsw;
|
|
} while_each_thread(first, tsk);
|
|
|
|
unlock_task_sighand(first, &flags);
|
|
rc = 0;
|
|
out:
|
|
rcu_read_unlock();
|
|
|
|
stats->version = TASKSTATS_VERSION;
|
|
/*
|
|
* Accounting subsystems can also add calls here to modify
|
|
* fields of taskstats.
|
|
*/
|
|
return rc;
|
|
}
|
|
|
|
static void fill_tgid_exit(struct task_struct *tsk)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tsk->sighand->siglock, flags);
|
|
if (!tsk->signal->stats)
|
|
goto ret;
|
|
|
|
/*
|
|
* Each accounting subsystem calls its functions here to
|
|
* accumalate its per-task stats for tsk, into the per-tgid structure
|
|
*
|
|
* per-task-foo(tsk->signal->stats, tsk);
|
|
*/
|
|
delayacct_add_tsk(tsk->signal->stats, tsk);
|
|
ret:
|
|
spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
|
|
return;
|
|
}
|
|
|
|
static int add_del_listener(pid_t pid, const struct cpumask *mask, int isadd)
|
|
{
|
|
struct listener_list *listeners;
|
|
struct listener *s, *tmp, *s2;
|
|
unsigned int cpu;
|
|
int ret = 0;
|
|
|
|
if (!cpumask_subset(mask, cpu_possible_mask))
|
|
return -EINVAL;
|
|
|
|
if (current_user_ns() != &init_user_ns)
|
|
return -EINVAL;
|
|
|
|
if (task_active_pid_ns(current) != &init_pid_ns)
|
|
return -EINVAL;
|
|
|
|
if (isadd == REGISTER) {
|
|
for_each_cpu(cpu, mask) {
|
|
s = kmalloc_node(sizeof(struct listener),
|
|
GFP_KERNEL, cpu_to_node(cpu));
|
|
if (!s) {
|
|
ret = -ENOMEM;
|
|
goto cleanup;
|
|
}
|
|
s->pid = pid;
|
|
s->valid = 1;
|
|
|
|
listeners = &per_cpu(listener_array, cpu);
|
|
down_write(&listeners->sem);
|
|
list_for_each_entry(s2, &listeners->list, list) {
|
|
if (s2->pid == pid && s2->valid)
|
|
goto exists;
|
|
}
|
|
list_add(&s->list, &listeners->list);
|
|
s = NULL;
|
|
exists:
|
|
up_write(&listeners->sem);
|
|
kfree(s); /* nop if NULL */
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Deregister or cleanup */
|
|
cleanup:
|
|
for_each_cpu(cpu, mask) {
|
|
listeners = &per_cpu(listener_array, cpu);
|
|
down_write(&listeners->sem);
|
|
list_for_each_entry_safe(s, tmp, &listeners->list, list) {
|
|
if (s->pid == pid) {
|
|
list_del(&s->list);
|
|
kfree(s);
|
|
break;
|
|
}
|
|
}
|
|
up_write(&listeners->sem);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int parse(struct nlattr *na, struct cpumask *mask)
|
|
{
|
|
char *data;
|
|
int len;
|
|
int ret;
|
|
|
|
if (na == NULL)
|
|
return 1;
|
|
len = nla_len(na);
|
|
if (len > TASKSTATS_CPUMASK_MAXLEN)
|
|
return -E2BIG;
|
|
if (len < 1)
|
|
return -EINVAL;
|
|
data = kmalloc(len, GFP_KERNEL);
|
|
if (!data)
|
|
return -ENOMEM;
|
|
nla_strlcpy(data, na, len);
|
|
ret = cpulist_parse(data, mask);
|
|
kfree(data);
|
|
return ret;
|
|
}
|
|
|
|
static struct taskstats *mk_reply(struct sk_buff *skb, int type, u32 pid)
|
|
{
|
|
struct nlattr *na, *ret;
|
|
int aggr;
|
|
|
|
aggr = (type == TASKSTATS_TYPE_PID)
|
|
? TASKSTATS_TYPE_AGGR_PID
|
|
: TASKSTATS_TYPE_AGGR_TGID;
|
|
|
|
na = nla_nest_start(skb, aggr);
|
|
if (!na)
|
|
goto err;
|
|
|
|
if (nla_put(skb, type, sizeof(pid), &pid) < 0) {
|
|
nla_nest_cancel(skb, na);
|
|
goto err;
|
|
}
|
|
ret = nla_reserve_64bit(skb, TASKSTATS_TYPE_STATS,
|
|
sizeof(struct taskstats), TASKSTATS_TYPE_NULL);
|
|
if (!ret) {
|
|
nla_nest_cancel(skb, na);
|
|
goto err;
|
|
}
|
|
nla_nest_end(skb, na);
|
|
|
|
return nla_data(ret);
|
|
err:
|
|
return NULL;
|
|
}
|
|
|
|
#define K(x) ((x) << (PAGE_SHIFT - 10))
|
|
#ifndef CONFIG_NUMA
|
|
static void sysstats_fill_zoneinfo(struct sys_memstats *stats)
|
|
{
|
|
pg_data_t *pgdat;
|
|
struct zone *zone;
|
|
struct zone *node_zones;
|
|
unsigned long zspages = 0;
|
|
|
|
pgdat = NODE_DATA(0);
|
|
node_zones = pgdat->node_zones;
|
|
|
|
for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
|
|
if (!populated_zone(zone))
|
|
continue;
|
|
|
|
zspages += zone_page_state(zone, NR_ZSPAGES);
|
|
if (!strcmp(zone->name, "DMA")) {
|
|
stats->dma_nr_free_pages =
|
|
K(zone_page_state(zone, NR_FREE_PAGES));
|
|
stats->dma_nr_active_anon =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON));
|
|
stats->dma_nr_inactive_anon =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON));
|
|
stats->dma_nr_active_file =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE));
|
|
stats->dma_nr_inactive_file =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE));
|
|
} else if (!strcmp(zone->name, "Normal")) {
|
|
stats->normal_nr_free_pages =
|
|
K(zone_page_state(zone, NR_FREE_PAGES));
|
|
stats->normal_nr_active_anon =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON));
|
|
stats->normal_nr_inactive_anon =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON));
|
|
stats->normal_nr_active_file =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE));
|
|
stats->normal_nr_inactive_file =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE));
|
|
} else if (!strcmp(zone->name, "HighMem")) {
|
|
stats->highmem_nr_free_pages =
|
|
K(zone_page_state(zone, NR_FREE_PAGES));
|
|
stats->highmem_nr_active_anon =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON));
|
|
stats->highmem_nr_inactive_anon =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON));
|
|
stats->highmem_nr_active_file =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE));
|
|
stats->highmem_nr_inactive_file =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE));
|
|
} else if (!strcmp(zone->name, "Movable")) {
|
|
stats->movable_nr_free_pages =
|
|
K(zone_page_state(zone, NR_FREE_PAGES));
|
|
stats->movable_nr_active_anon =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON));
|
|
stats->movable_nr_inactive_anon =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON));
|
|
stats->movable_nr_active_file =
|
|
K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE));
|
|
stats->movable_nr_inactive_file =
|
|
K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE));
|
|
}
|
|
}
|
|
stats->zram_compressed = K(zspages);
|
|
}
|
|
#elif
|
|
static void sysstats_fill_zoneinfo(struct sys_memstats *stats)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static void sysstats_build(struct sys_memstats *stats)
|
|
{
|
|
struct sysinfo i;
|
|
|
|
si_meminfo(&i);
|
|
si_swapinfo(&i);
|
|
|
|
stats->version = SYSSTATS_VERSION;
|
|
stats->memtotal = K(i.totalram);
|
|
stats->reclaimable =
|
|
K(global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE));
|
|
stats->swap_used = K(i.totalswap - i.freeswap);
|
|
stats->swap_total = K(i.totalswap);
|
|
stats->vmalloc_total = K(vmalloc_nr_pages());
|
|
stats->unreclaimable =
|
|
K(global_node_page_state(NR_UNRECLAIMABLE_PAGES));
|
|
stats->buffer = K(i.bufferram);
|
|
stats->swapcache = K(total_swapcache_pages());
|
|
stats->slab_reclaimable =
|
|
K(global_node_page_state(NR_SLAB_RECLAIMABLE));
|
|
stats->slab_unreclaimable =
|
|
K(global_node_page_state(NR_SLAB_UNRECLAIMABLE));
|
|
stats->free_cma = K(global_zone_page_state(NR_FREE_CMA_PAGES));
|
|
stats->file_mapped = K(global_node_page_state(NR_FILE_MAPPED));
|
|
stats->kernelstack = global_zone_page_state(NR_KERNEL_STACK_KB);
|
|
stats->pagetable = K(global_zone_page_state(NR_PAGETABLE));
|
|
stats->shmem = K(i.sharedram);
|
|
sysstats_fill_zoneinfo(stats);
|
|
}
|
|
#undef K
|
|
|
|
static int sysstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
int rc = 0;
|
|
struct sk_buff *rep_skb;
|
|
struct sys_memstats *stats;
|
|
struct nlattr *na;
|
|
size_t size;
|
|
|
|
size = nla_total_size(sizeof(struct sys_memstats));
|
|
|
|
rc = prepare_reply(info, SYSSTATS_CMD_NEW, &rep_skb,
|
|
size);
|
|
if (rc < 0)
|
|
goto err;
|
|
|
|
na = nla_reserve(rep_skb, SYSSTATS_TYPE_SYSMEM_STATS,
|
|
sizeof(struct sys_memstats));
|
|
if (na == NULL) {
|
|
nlmsg_free(rep_skb);
|
|
rc = -EMSGSIZE;
|
|
goto err;
|
|
}
|
|
|
|
stats = nla_data(na);
|
|
memset(stats, 0, sizeof(*stats));
|
|
|
|
sysstats_build(stats);
|
|
|
|
rc = send_reply(rep_skb, info);
|
|
|
|
err:
|
|
return rc;
|
|
}
|
|
|
|
static int cgroupstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
int rc = 0;
|
|
struct sk_buff *rep_skb;
|
|
struct cgroupstats *stats;
|
|
struct nlattr *na;
|
|
size_t size;
|
|
u32 fd;
|
|
struct fd f;
|
|
|
|
na = info->attrs[CGROUPSTATS_CMD_ATTR_FD];
|
|
if (!na)
|
|
return -EINVAL;
|
|
|
|
fd = nla_get_u32(info->attrs[CGROUPSTATS_CMD_ATTR_FD]);
|
|
f = fdget(fd);
|
|
if (!f.file)
|
|
return 0;
|
|
|
|
size = nla_total_size(sizeof(struct cgroupstats));
|
|
|
|
rc = prepare_reply(info, CGROUPSTATS_CMD_NEW, &rep_skb,
|
|
size);
|
|
if (rc < 0)
|
|
goto err;
|
|
|
|
na = nla_reserve(rep_skb, CGROUPSTATS_TYPE_CGROUP_STATS,
|
|
sizeof(struct cgroupstats));
|
|
if (na == NULL) {
|
|
nlmsg_free(rep_skb);
|
|
rc = -EMSGSIZE;
|
|
goto err;
|
|
}
|
|
|
|
stats = nla_data(na);
|
|
memset(stats, 0, sizeof(*stats));
|
|
|
|
rc = cgroupstats_build(stats, f.file->f_path.dentry);
|
|
if (rc < 0) {
|
|
nlmsg_free(rep_skb);
|
|
goto err;
|
|
}
|
|
|
|
rc = send_reply(rep_skb, info);
|
|
|
|
err:
|
|
fdput(f);
|
|
return rc;
|
|
}
|
|
|
|
static int cmd_attr_register_cpumask(struct genl_info *info)
|
|
{
|
|
cpumask_var_t mask;
|
|
int rc;
|
|
|
|
if (!alloc_cpumask_var(&mask, GFP_KERNEL))
|
|
return -ENOMEM;
|
|
rc = parse(info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK], mask);
|
|
if (rc < 0)
|
|
goto out;
|
|
rc = add_del_listener(info->snd_portid, mask, REGISTER);
|
|
out:
|
|
free_cpumask_var(mask);
|
|
return rc;
|
|
}
|
|
|
|
static int cmd_attr_deregister_cpumask(struct genl_info *info)
|
|
{
|
|
cpumask_var_t mask;
|
|
int rc;
|
|
|
|
if (!alloc_cpumask_var(&mask, GFP_KERNEL))
|
|
return -ENOMEM;
|
|
rc = parse(info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK], mask);
|
|
if (rc < 0)
|
|
goto out;
|
|
rc = add_del_listener(info->snd_portid, mask, DEREGISTER);
|
|
out:
|
|
free_cpumask_var(mask);
|
|
return rc;
|
|
}
|
|
|
|
static size_t taskstats_packet_size(void)
|
|
{
|
|
size_t size;
|
|
|
|
size = nla_total_size(sizeof(u32)) +
|
|
nla_total_size_64bit(sizeof(struct taskstats)) +
|
|
nla_total_size(0);
|
|
|
|
return size;
|
|
}
|
|
|
|
static int taskstats2_cmd_attr_pid(struct genl_info *info)
|
|
{
|
|
struct taskstats2 *stats;
|
|
struct sk_buff *rep_skb;
|
|
struct nlattr *ret;
|
|
struct task_struct *tsk;
|
|
struct task_struct *p;
|
|
size_t size;
|
|
u32 pid;
|
|
int rc;
|
|
|
|
size = nla_total_size_64bit(sizeof(struct taskstats2));
|
|
|
|
rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
rc = -EINVAL;
|
|
pid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_PID]);
|
|
|
|
ret = nla_reserve_64bit(rep_skb, TASKSTATS_TYPE_STATS,
|
|
sizeof(struct taskstats2), TASKSTATS_TYPE_NULL);
|
|
if (!ret)
|
|
goto err;
|
|
|
|
stats = nla_data(ret);
|
|
|
|
rcu_read_lock();
|
|
tsk = find_task_by_vpid(pid);
|
|
if (tsk)
|
|
get_task_struct(tsk);
|
|
rcu_read_unlock();
|
|
if (!tsk) {
|
|
rc = -ESRCH;
|
|
goto err;
|
|
}
|
|
memset(stats, 0, sizeof(*stats));
|
|
stats->version = TASKSTATS2_VERSION;
|
|
stats->pid = task_pid_nr_ns(tsk, task_active_pid_ns(current));
|
|
p = find_lock_task_mm(tsk);
|
|
if (p) {
|
|
#define K(x) ((x) << (PAGE_SHIFT - 10))
|
|
stats->anon_rss = K(get_mm_counter(p->mm, MM_ANONPAGES));
|
|
stats->file_rss = K(get_mm_counter(p->mm, MM_FILEPAGES));
|
|
stats->shmem_rss = K(get_mm_counter(p->mm, MM_SHMEMPAGES));
|
|
stats->swap_rss = K(get_mm_counter(p->mm, MM_SWAPENTS));
|
|
stats->unreclaimable =
|
|
K(get_mm_counter(p->mm, MM_UNRECLAIMABLE));
|
|
#undef K
|
|
task_unlock(p);
|
|
}
|
|
put_task_struct(tsk);
|
|
|
|
return send_reply(rep_skb, info);
|
|
err:
|
|
nlmsg_free(rep_skb);
|
|
return rc;
|
|
}
|
|
|
|
static int cmd_attr_pid(struct genl_info *info)
|
|
{
|
|
struct taskstats *stats;
|
|
struct sk_buff *rep_skb;
|
|
size_t size;
|
|
u32 pid;
|
|
int rc;
|
|
|
|
size = taskstats_packet_size();
|
|
|
|
rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
rc = -EINVAL;
|
|
pid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_PID]);
|
|
stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID, pid);
|
|
if (!stats)
|
|
goto err;
|
|
|
|
rc = fill_stats_for_pid(pid, stats);
|
|
if (rc < 0)
|
|
goto err;
|
|
return send_reply(rep_skb, info);
|
|
err:
|
|
nlmsg_free(rep_skb);
|
|
return rc;
|
|
}
|
|
|
|
static int cmd_attr_tgid(struct genl_info *info)
|
|
{
|
|
struct taskstats *stats;
|
|
struct sk_buff *rep_skb;
|
|
size_t size;
|
|
u32 tgid;
|
|
int rc;
|
|
|
|
size = taskstats_packet_size();
|
|
|
|
rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
rc = -EINVAL;
|
|
tgid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_TGID]);
|
|
stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID, tgid);
|
|
if (!stats)
|
|
goto err;
|
|
|
|
rc = fill_stats_for_tgid(tgid, stats);
|
|
if (rc < 0)
|
|
goto err;
|
|
return send_reply(rep_skb, info);
|
|
err:
|
|
nlmsg_free(rep_skb);
|
|
return rc;
|
|
}
|
|
|
|
static struct tgid_iter next_tgid(struct pid_namespace *ns,
|
|
struct tgid_iter iter)
|
|
{
|
|
struct pid *pid;
|
|
|
|
if (iter.task)
|
|
put_task_struct(iter.task);
|
|
rcu_read_lock();
|
|
retry:
|
|
iter.task = NULL;
|
|
pid = find_ge_pid(iter.tgid, ns);
|
|
if (pid) {
|
|
iter.tgid = pid_nr_ns(pid, ns);
|
|
iter.task = pid_task(pid, PIDTYPE_PID);
|
|
if (!iter.task || !has_group_leader_pid(iter.task)) {
|
|
iter.tgid += 1;
|
|
goto retry;
|
|
}
|
|
get_task_struct(iter.task);
|
|
}
|
|
rcu_read_unlock();
|
|
return iter;
|
|
}
|
|
|
|
static int taskstats2_foreach(struct sk_buff *skb, struct netlink_callback *cb)
|
|
{
|
|
struct pid_namespace *ns = task_active_pid_ns(current);
|
|
struct tgid_iter iter;
|
|
void *reply;
|
|
struct nlattr *attr;
|
|
struct nlattr *nla;
|
|
struct taskstats2 *stats;
|
|
struct task_struct *p;
|
|
short oom_score;
|
|
short oom_score_min;
|
|
short oom_score_max;
|
|
u32 buf;
|
|
|
|
nla = nla_find(nlmsg_attrdata(cb->nlh, GENL_HDRLEN),
|
|
nlmsg_attrlen(cb->nlh, GENL_HDRLEN),
|
|
TASKSTATS_TYPE_FOREACH);
|
|
|
|
if (!nla)
|
|
goto out;
|
|
|
|
buf = nla_get_u32(nla);
|
|
oom_score_min = (short) (buf & 0xFFFF);
|
|
oom_score_max = (short) ((buf >> 16) & 0xFFFF);
|
|
|
|
iter.tgid = cb->args[0];
|
|
iter.task = NULL;
|
|
for (iter = next_tgid(ns, iter); iter.task;
|
|
iter.tgid += 1, iter = next_tgid(ns, iter)) {
|
|
|
|
if (iter.task->flags & PF_KTHREAD)
|
|
continue;
|
|
|
|
oom_score = iter.task->signal->oom_score_adj;
|
|
if ((oom_score < oom_score_min)
|
|
|| (oom_score > oom_score_max))
|
|
continue;
|
|
|
|
reply = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
|
|
cb->nlh->nlmsg_seq, &family, 0, TASKSTATS2_CMD_GET);
|
|
if (reply == NULL) {
|
|
put_task_struct(iter.task);
|
|
break;
|
|
}
|
|
attr = nla_reserve(skb, TASKSTATS_TYPE_FOREACH,
|
|
sizeof(struct taskstats2));
|
|
if (!attr) {
|
|
put_task_struct(iter.task);
|
|
genlmsg_cancel(skb, reply);
|
|
break;
|
|
}
|
|
stats = nla_data(attr);
|
|
memset(stats, 0, sizeof(struct taskstats2));
|
|
stats->version = TASKSTATS2_VERSION;
|
|
rcu_read_lock();
|
|
stats->pid = task_pid_nr_ns(iter.task,
|
|
task_active_pid_ns(current));
|
|
stats->oom_score = iter.task->signal->oom_score_adj;
|
|
rcu_read_unlock();
|
|
p = find_lock_task_mm(iter.task);
|
|
if (p) {
|
|
#define K(x) ((x) << (PAGE_SHIFT - 10))
|
|
stats->anon_rss =
|
|
K(get_mm_counter(p->mm, MM_ANONPAGES));
|
|
stats->file_rss =
|
|
K(get_mm_counter(p->mm, MM_FILEPAGES));
|
|
stats->shmem_rss =
|
|
K(get_mm_counter(p->mm, MM_SHMEMPAGES));
|
|
stats->swap_rss =
|
|
K(get_mm_counter(p->mm, MM_SWAPENTS));
|
|
task_unlock(p);
|
|
#undef K
|
|
}
|
|
genlmsg_end(skb, reply);
|
|
}
|
|
|
|
cb->args[0] = iter.tgid;
|
|
out:
|
|
return skb->len;
|
|
}
|
|
|
|
static int taskstats2_user_cmd(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
if (info->attrs[TASKSTATS_CMD_ATTR_PID])
|
|
return taskstats2_cmd_attr_pid(info);
|
|
else
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int taskstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
if (info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK])
|
|
return cmd_attr_register_cpumask(info);
|
|
else if (info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK])
|
|
return cmd_attr_deregister_cpumask(info);
|
|
else if (info->attrs[TASKSTATS_CMD_ATTR_PID])
|
|
return cmd_attr_pid(info);
|
|
else if (info->attrs[TASKSTATS_CMD_ATTR_TGID])
|
|
return cmd_attr_tgid(info);
|
|
else
|
|
return -EINVAL;
|
|
}
|
|
|
|
static struct taskstats *taskstats_tgid_alloc(struct task_struct *tsk)
|
|
{
|
|
struct signal_struct *sig = tsk->signal;
|
|
struct taskstats *stats_new, *stats;
|
|
|
|
/* Pairs with smp_store_release() below. */
|
|
stats = smp_load_acquire(&sig->stats);
|
|
if (stats || thread_group_empty(tsk))
|
|
return stats;
|
|
|
|
/* No problem if kmem_cache_zalloc() fails */
|
|
stats_new = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
|
|
|
|
spin_lock_irq(&tsk->sighand->siglock);
|
|
stats = sig->stats;
|
|
if (!stats) {
|
|
/*
|
|
* Pairs with smp_store_release() above and order the
|
|
* kmem_cache_zalloc().
|
|
*/
|
|
smp_store_release(&sig->stats, stats_new);
|
|
stats = stats_new;
|
|
stats_new = NULL;
|
|
}
|
|
spin_unlock_irq(&tsk->sighand->siglock);
|
|
|
|
if (stats_new)
|
|
kmem_cache_free(taskstats_cache, stats_new);
|
|
|
|
return stats;
|
|
}
|
|
|
|
/* Send pid data out on exit */
|
|
void taskstats_exit(struct task_struct *tsk, int group_dead)
|
|
{
|
|
int rc;
|
|
struct listener_list *listeners;
|
|
struct taskstats *stats;
|
|
struct sk_buff *rep_skb;
|
|
size_t size;
|
|
int is_thread_group;
|
|
|
|
if (!family_registered)
|
|
return;
|
|
|
|
/*
|
|
* Size includes space for nested attributes
|
|
*/
|
|
size = taskstats_packet_size();
|
|
|
|
is_thread_group = !!taskstats_tgid_alloc(tsk);
|
|
if (is_thread_group) {
|
|
/* PID + STATS + TGID + STATS */
|
|
size = 2 * size;
|
|
/* fill the tsk->signal->stats structure */
|
|
fill_tgid_exit(tsk);
|
|
}
|
|
|
|
listeners = raw_cpu_ptr(&listener_array);
|
|
if (list_empty(&listeners->list))
|
|
return;
|
|
|
|
rc = prepare_reply(NULL, TASKSTATS_CMD_NEW, &rep_skb, size);
|
|
if (rc < 0)
|
|
return;
|
|
|
|
stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID,
|
|
task_pid_nr_ns(tsk, &init_pid_ns));
|
|
if (!stats)
|
|
goto err;
|
|
|
|
fill_stats(&init_user_ns, &init_pid_ns, tsk, stats);
|
|
|
|
/*
|
|
* Doesn't matter if tsk is the leader or the last group member leaving
|
|
*/
|
|
if (!is_thread_group || !group_dead)
|
|
goto send;
|
|
|
|
stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID,
|
|
task_tgid_nr_ns(tsk, &init_pid_ns));
|
|
if (!stats)
|
|
goto err;
|
|
|
|
memcpy(stats, tsk->signal->stats, sizeof(*stats));
|
|
|
|
send:
|
|
send_cpu_listeners(rep_skb, listeners);
|
|
return;
|
|
err:
|
|
nlmsg_free(rep_skb);
|
|
}
|
|
|
|
static const struct genl_ops taskstats_ops[] = {
|
|
{
|
|
.cmd = TASKSTATS_CMD_GET,
|
|
.doit = taskstats_user_cmd,
|
|
.policy = taskstats_cmd_get_policy,
|
|
.flags = GENL_ADMIN_PERM,
|
|
},
|
|
{
|
|
.cmd = TASKSTATS2_CMD_GET,
|
|
.doit = taskstats2_user_cmd,
|
|
.dumpit = taskstats2_foreach,
|
|
.policy = taskstats_cmd_get_policy,
|
|
},
|
|
{
|
|
.cmd = CGROUPSTATS_CMD_GET,
|
|
.doit = cgroupstats_user_cmd,
|
|
.policy = cgroupstats_cmd_get_policy,
|
|
},
|
|
{
|
|
.cmd = SYSSTATS_CMD_GET,
|
|
.doit = sysstats_user_cmd,
|
|
.policy = sysstats_cmd_get_policy,
|
|
},
|
|
};
|
|
|
|
static struct genl_family family __ro_after_init = {
|
|
.name = TASKSTATS_GENL_NAME,
|
|
.version = TASKSTATS_GENL_VERSION,
|
|
.maxattr = TASKSTATS_CMD_ATTR_MAX,
|
|
.module = THIS_MODULE,
|
|
.ops = taskstats_ops,
|
|
.n_ops = ARRAY_SIZE(taskstats_ops),
|
|
};
|
|
|
|
/* Needed early in initialization */
|
|
void __init taskstats_init_early(void)
|
|
{
|
|
unsigned int i;
|
|
|
|
taskstats_cache = KMEM_CACHE(taskstats, SLAB_PANIC);
|
|
for_each_possible_cpu(i) {
|
|
INIT_LIST_HEAD(&(per_cpu(listener_array, i).list));
|
|
init_rwsem(&(per_cpu(listener_array, i).sem));
|
|
}
|
|
}
|
|
|
|
static int __init taskstats_init(void)
|
|
{
|
|
int rc;
|
|
|
|
rc = genl_register_family(&family);
|
|
if (rc)
|
|
return rc;
|
|
|
|
family_registered = 1;
|
|
pr_info("registered taskstats version %d\n", TASKSTATS_GENL_VERSION);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* late initcall ensures initialization of statistics collection
|
|
* mechanisms precedes initialization of the taskstats interface
|
|
*/
|
|
late_initcall(taskstats_init);
|