ce7025b713
-----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAmJZYdEACgkQONu9yGCS aT4TOA//QvLAUigiHT1OP1mgJtr4p8EIeCtB26Z7U+PDpe1bq2XojW1Qosflcp26 /7auxf503Ju+wjKFjqzAD3Nwvl11M8Be/YOjJdAU5XHNO3eD2O+1Nwk8t1XELF1S xA7QUk9OjrAosjrH1QpUOVB5nZps8qSB83QwfUAE8j0qvWvio3zxrRbv+aWyaP+P n7B7kxMLL65Obvgkkepn5247t2v1kiauZSmigr7e0i7OZ5af3uEscg3gUDLOsfud ib1VmKGXMQHnyV6FRrPMMrZwcKutc55wGMG/XOCIRzCS5MUgtDRU9biNzsxS+w8W DO83BD01LIWKJ4Z6yhBTlR2IVCH9dW2zGbXDWXvCk4FD4+mpwJYfV64mAS/OUPI4 j61l9pKvDipRTsoTq9EZ7aNJv99O+L9abxQMRIHa0z/NrOaqmhd4VKvlw+BU8x9a vbNY4B0A3WBWe+rSVVKurxT1YIyrLiSmcTrXQn+ViptOZrAvlUcTqf5NU6JXVLiT RZJscnEV5uMDanxictWmp1zWsy1pqv9NQiKNXcJ31AnUN7+xT722H26Z7bX0a5/3 HJ97zwgsfgJfePhXGW7HUh7/NRNfzYha0VkYxPkE7vMQ6P3UjniE4R+Kg+QiNdGR Fil85X0KiOOAuwWpS36Aj2vmvV6QmMWJZh9HSSpRMIpTbKAU+t4= =fkd3 -----END PGP SIGNATURE----- Merge 4.19.238 into android-4.19-stable Changes in 4.19.238 USB: serial: pl2303: add IBM device IDs USB: serial: simple: add Nokia phone driver netdevice: add the case if dev is NULL xfrm: fix tunnel model fragmentation behavior virtio_console: break out of buf poll on remove ethernet: sun: Free the coherent when failing in probing spi: Fix invalid sgs value net:mcf8390: Use platform_get_irq() to get the interrupt spi: Fix erroneous sgs value with min_t() af_key: add __GFP_ZERO flag for compose_sadb_supported in function pfkey_register fuse: fix pipe buffer lifetime for direct_io tpm: fix reference counting for struct tpm_chip block: Add a helper to validate the block size virtio-blk: Use blk_validate_block_size() to validate block size USB: usb-storage: Fix use of bitfields for hardware data in ene_ub6250.c xhci: make xhci_handshake timeout for xhci_reset() adjustable coresight: Fix TRCCONFIGR.QE sysfs interface iio: afe: rescale: use s64 for temporary scale calculations iio: inkern: apply consumer scale on IIO_VAL_INT cases iio: inkern: apply consumer scale when no channel scale is available iio: inkern: make a best effort on offset calculation clk: uniphier: Fix fixed-rate initialization ptrace: Check PTRACE_O_SUSPEND_SECCOMP permission on PTRACE_SEIZE Documentation: add link to stable release candidate tree Documentation: update stable tree link SUNRPC: avoid race between mod_timer() and del_timer_sync() NFSD: prevent underflow in nfssvc_decode_writeargs() NFSD: prevent integer overflow on 32 bit systems f2fs: fix to unlock page correctly in error path of is_alive() pinctrl: samsung: drop pin banks references on error paths can: ems_usb: ems_usb_start_xmit(): fix double dev_kfree_skb() in error path jffs2: fix use-after-free in jffs2_clear_xattr_subsystem jffs2: fix memory leak in jffs2_do_mount_fs jffs2: fix memory leak in jffs2_scan_medium mm/pages_alloc.c: don't create ZONE_MOVABLE beyond the end of a node mm: invalidate hwpoison page cache page in fault path mempolicy: mbind_range() set_policy() after vma_merge() scsi: libsas: Fix sas_ata_qc_issue() handling of NCQ NON DATA commands qed: display VF trust config qed: validate and restrict untrusted VFs vlan promisc mode Revert "Input: clear BTN_RIGHT/MIDDLE on buttonpads" ALSA: cs4236: fix an incorrect NULL check on list iterator ALSA: hda/realtek: Fix audio regression on Mi Notebook Pro 2020 mm,hwpoison: unmap poisoned page before invalidation drbd: fix potential silent data corruption powerpc/kvm: Fix kvm_use_magic_page ACPI: properties: Consistently return -ENOENT if there are no more references drivers: hamradio: 6pack: fix UAF bug caused by mod_timer() block: don't merge across cgroup boundaries if blkcg is enabled drm/edid: check basic audio support on CEA extension block video: fbdev: sm712fb: Fix crash in smtcfb_read() video: fbdev: atari: Atari 2 bpp (STe) palette bugfix ARM: dts: at91: sama5d2: Fix PMERRLOC resource size ARM: dts: exynos: fix UART3 pins configuration in Exynos5250 ARM: dts: exynos: add missing HDMI supplies on SMDK5250 ARM: dts: exynos: add missing HDMI supplies on SMDK5420 carl9170: fix missing bit-wise or operator for tx_params thermal: int340x: Increase bitmap size lib/raid6/test: fix multiple definition linking error DEC: Limit PMAX memory probing to R3k systems media: davinci: vpif: fix unbalanced runtime PM get brcmfmac: firmware: Allocate space for default boardrev in nvram brcmfmac: pcie: Replace brcmf_pcie_copy_mem_todev with memcpy_toio PCI: pciehp: Clear cmd_busy bit in polling mode regulator: qcom_smd: fix for_each_child.cocci warnings crypto: authenc - Fix sleep in atomic context in decrypt_tail crypto: mxs-dcp - Fix scatterlist processing spi: tegra114: Add missing IRQ check in tegra_spi_probe selftests/x86: Add validity check and allow field splitting spi: pxa2xx-pci: Balance reference count for PCI DMA device hwmon: (pmbus) Add mutex to regulator ops hwmon: (sch56xx-common) Replace WDOG_ACTIVE with WDOG_HW_RUNNING block: don't delete queue kobject before its children PM: hibernate: fix __setup handler error handling PM: suspend: fix return value of __setup handler hwrng: atmel - disable trng on failure path crypto: vmx - add missing dependencies clocksource/drivers/timer-of: Check return value of of_iomap in timer_of_base_init() ACPI: APEI: fix return value of __setup handlers crypto: ccp - ccp_dmaengine_unregister release dma channels hwmon: (pmbus) Add Vin unit off handling clocksource: acpi_pm: fix return value of __setup handler sched/debug: Remove mpol_get/put and task_lock/unlock from sched_show_numa perf/core: Fix address filter parser for multiple filters perf/x86/intel/pt: Fix address filter config for 32-bit kernel media: coda: Fix missing put_device() call in coda_get_vdoa_data video: fbdev: smscufx: Fix null-ptr-deref in ufx_usb_probe() video: fbdev: fbcvt.c: fix printing in fb_cvt_print_name() ARM: dts: qcom: ipq4019: fix sleep clock soc: ti: wkup_m3_ipc: Fix IRQ check in wkup_m3_ipc_probe media: em28xx: initialize refcount before kref_get media: usb: go7007: s2250-board: fix leak in probe() ASoC: rt5663: check the return value of devm_kzalloc() in rt5663_parse_dp() ASoC: ti: davinci-i2s: Add check for clk_enable() ALSA: spi: Add check for clk_enable() arm64: dts: ns2: Fix spi-cpol and spi-cpha property arm64: dts: broadcom: Fix sata nodename printk: fix return value of printk.devkmsg __setup handler ASoC: mxs-saif: Handle errors for clk_enable ASoC: atmel_ssc_dai: Handle errors for clk_enable memory: emif: Add check for setup_interrupts memory: emif: check the pointer temp in get_device_details() ALSA: firewire-lib: fix uninitialized flag for AV/C deferred transaction media: stk1160: If start stream fails, return buffers with VB2_BUF_STATE_QUEUED ASoC: atmel: Add missing of_node_put() in at91sam9g20ek_audio_probe ASoC: wm8350: Handle error for wm8350_register_irq ASoC: fsi: Add check for clk_enable video: fbdev: omapfb: Add missing of_node_put() in dvic_probe_of ASoC: dmaengine: do not use a NULL prepare_slave_config() callback ASoC: mxs: Fix error handling in mxs_sgtl5000_probe ASoC: imx-es8328: Fix error return code in imx_es8328_probe() ASoC: msm8916-wcd-digital: Fix missing clk_disable_unprepare() in msm8916_wcd_digital_probe mmc: davinci_mmc: Handle error for clk_enable drm/bridge: Fix free wrong object in sii8620_init_rcp_input_dev ath10k: fix memory overwrite of the WoWLAN wakeup packet pattern Bluetooth: hci_serdev: call init_rwsem() before p->open() mtd: onenand: Check for error irq drm/edid: Don't clear formats if using deep color drm/amd/display: Fix a NULL pointer dereference in amdgpu_dm_connector_add_common_modes() ath9k_htc: fix uninit value bugs KVM: PPC: Fix vmx/vsx mixup in mmio emulation power: reset: gemini-poweroff: Fix IRQ check in gemini_poweroff_probe ray_cs: Check ioremap return value power: supply: ab8500: Fix memory leak in ab8500_fg_sysfs_init HID: i2c-hid: fix GET/SET_REPORT for unnumbered reports iwlwifi: Fix -EIO error code that is never returned dm crypt: fix get_key_size compiler warning if !CONFIG_KEYS scsi: pm8001: Fix command initialization in pm80XX_send_read_log() scsi: pm8001: Fix command initialization in pm8001_chip_ssp_tm_req() scsi: pm8001: Fix payload initialization in pm80xx_set_thermal_config() scsi: pm8001: Fix abort all task initialization TOMOYO: fix __setup handlers return values ext2: correct max file size computing drm/tegra: Fix reference leak in tegra_dsi_ganged_probe power: supply: bq24190_charger: Fix bq24190_vbus_is_enabled() wrong false return drm/bridge: cdns-dsi: Make sure to to create proper aliases for dt powerpc/Makefile: Don't pass -mcpu=powerpc64 when building 32-bit KVM: x86: Fix emulation in writing cr8 KVM: x86/emulator: Defer not-present segment check in __load_segment_descriptor() hv_balloon: rate-limit "Unhandled message" warning i2c: xiic: Make bus names unique power: supply: wm8350-power: Handle error for wm8350_register_irq power: supply: wm8350-power: Add missing free in free_charger_irq PCI: Reduce warnings on possible RW1C corruption powerpc/sysdev: fix incorrect use to determine if list is empty mfd: mc13xxx: Add check for mc13xxx_irq_request vxcan: enable local echo for sent CAN frames MIPS: RB532: fix return value of __setup handler mtd: rawnand: atmel: fix refcount issue in atmel_nand_controller_init USB: storage: ums-realtek: fix error code in rts51x_read_mem() af_netlink: Fix shift out of bounds in group mask calculation i2c: mux: demux-pinctrl: do not deactivate a master that is not active selftests/bpf/test_lirc_mode2.sh: Exit with proper code tcp: ensure PMTU updates are processed during fastopen mfd: asic3: Add missing iounmap() on error asic3_mfd_probe mxser: fix xmit_buf leak in activate when LSR == 0xff pwm: lpc18xx-sct: Initialize driver data and hardware before pwmchip_add() staging:iio:adc:ad7280a: Fix handing of device address bit reversing. clk: qcom: ipq8074: Use floor ops for SDCC1 clock serial: 8250_mid: Balance reference count for PCI DMA device serial: 8250: Fix race condition in RTS-after-send handling iio: adc: Add check for devm_request_threaded_irq dma-debug: fix return value of __setup handlers clk: qcom: clk-rcg2: Update the frac table for pixel clock remoteproc: qcom_wcnss: Add missing of_node_put() in wcnss_alloc_memory_region clk: actions: Terminate clk_div_table with sentinel element clk: loongson1: Terminate clk_div_table with sentinel element clk: clps711x: Terminate clk_div_table with sentinel element clk: tegra: tegra124-emc: Fix missing put_device() call in emc_ensure_emc_driver NFS: remove unneeded check in decode_devicenotify_args() pinctrl: mediatek: Fix missing of_node_put() in mtk_pctrl_init pinctrl: nomadik: Add missing of_node_put() in nmk_pinctrl_probe pinctrl/rockchip: Add missing of_node_put() in rockchip_pinctrl_probe tty: hvc: fix return value of __setup handler kgdboc: fix return value of __setup handler kgdbts: fix return value of __setup handler jfs: fix divide error in dbNextAG netfilter: nf_conntrack_tcp: preserve liberal flag in tcp options clk: qcom: gcc-msm8994: Fix gpll4 width xen: fix is_xen_pmu() net: phy: broadcom: Fix brcm_fet_config_init() qlcnic: dcb: default to returning -EOPNOTSUPP net/x25: Fix null-ptr-deref caused by x25_disconnect NFSv4/pNFS: Fix another issue with a list iterator pointing to the head lib/test: use after free in register_test_dev_kmod() selinux: use correct type for context length loop: use sysfs_emit() in the sysfs xxx show() Fix incorrect type in assignment of ipv6 port for audit irqchip/qcom-pdc: Fix broken locking irqchip/nvic: Release nvic_base upon failure bfq: fix use-after-free in bfq_dispatch_request ACPICA: Avoid walking the ACPI Namespace if it is not there lib/raid6/test/Makefile: Use $(pound) instead of \# for Make 4.3 Revert "Revert "block, bfq: honor already-setup queue merges"" ACPI/APEI: Limit printable size of BERT table data PM: core: keep irq flags in device_pm_check_callbacks() spi: tegra20: Use of_device_get_match_data() ext4: don't BUG if someone dirty pages without asking ext4 first ntfs: add sanity check on allocation size video: fbdev: nvidiafb: Use strscpy() to prevent buffer overflow video: fbdev: w100fb: Reset global state video: fbdev: cirrusfb: check pixclock to avoid divide by zero video: fbdev: omapfb: acx565akm: replace snprintf with sysfs_emit ARM: dts: qcom: fix gic_irq_domain_translate warnings for msm8960 ARM: dts: bcm2837: Add the missing L1/L2 cache information video: fbdev: omapfb: panel-dsi-cm: Use sysfs_emit() instead of snprintf() video: fbdev: omapfb: panel-tpo-td043mtea1: Use sysfs_emit() instead of snprintf() video: fbdev: udlfb: replace snprintf in show functions with sysfs_emit ASoC: soc-core: skip zero num_dai component in searching dai name media: cx88-mpeg: clear interrupt status register before streaming video ARM: tegra: tamonten: Fix I2C3 pad setting ARM: mmp: Fix failure to remove sram device video: fbdev: sm712fb: Fix crash in smtcfb_write() media: Revert "media: em28xx: add missing em28xx_close_extension" media: hdpvr: initialize dev->worker at hdpvr_register_videodev mmc: host: Return an error when ->enable_sdio_irq() ops is missing powerpc/lib/sstep: Fix 'sthcx' instruction powerpc/lib/sstep: Fix build errors with newer binutils powerpc: Fix build errors with newer binutils scsi: qla2xxx: Fix stuck session in gpdb scsi: qla2xxx: Fix warning for missing error code scsi: qla2xxx: Check for firmware dump already collected scsi: qla2xxx: Suppress a kernel complaint in qla_create_qpair() scsi: qla2xxx: Fix incorrect reporting of task management failure scsi: qla2xxx: Fix hang due to session stuck scsi: qla2xxx: Reduce false trigger to login scsi: qla2xxx: Use correct feature type field during RFF_ID processing KVM: Prevent module exit until all VMs are freed KVM: x86: fix sending PV IPI ubifs: rename_whiteout: Fix double free for whiteout_ui->data ubifs: Fix deadlock in concurrent rename whiteout and inode writeback ubifs: Add missing iput if do_tmpfile() failed in rename whiteout ubifs: setflags: Make dirtied_ino_d 8 bytes aligned ubifs: Fix read out-of-bounds in ubifs_wbuf_write_nolock() ubifs: rename_whiteout: correct old_dir size computing can: mcba_usb: mcba_usb_start_xmit(): fix double dev_kfree_skb in error path can: mcba_usb: properly check endpoint type gfs2: Make sure FITRIM minlen is rounded up to fs block size pinctrl: pinconf-generic: Print arguments for bias-pull-* ubi: Fix race condition between ctrl_cdev_ioctl and ubi_cdev_ioctl ACPI: CPPC: Avoid out of bounds access when parsing _CPC data mm/mmap: return 1 from stack_guard_gap __setup() handler mm/memcontrol: return 1 from cgroup.memory __setup() handler mm/usercopy: return 1 from hardened_usercopy __setup() handler bpf: Fix comment for helper bpf_current_task_under_cgroup() ubi: fastmap: Return error code if memory allocation fails in add_aeb() ASoC: topology: Allow TLV control to be either read or write ARM: dts: spear1340: Update serial node properties ARM: dts: spear13xx: Update SPI dma properties um: Fix uml_mconsole stop/go openvswitch: Fixed nd target mask field in the flow dump. KVM: x86: Forbid VMM to set SYNIC/STIMER MSRs when SynIC wasn't activated ubifs: Rectify space amount budget for mkdir/tmpfile operations rtc: wm8350: Handle error for wm8350_register_irq riscv module: remove (NOLOAD) ARM: 9187/1: JIVE: fix return value of __setup handler KVM: x86/svm: Clear reserved bits written to PerfEvtSeln MSRs drm: Add orientation quirk for GPD Win Max ath5k: fix OOB in ath5k_eeprom_read_pcal_info_5111 drm/amd/amdgpu/amdgpu_cs: fix refcount leak of a dma_fence obj ptp: replace snprintf with sysfs_emit powerpc: dts: t104xrdb: fix phy type for FMAN 4/5 scsi: mvsas: Replace snprintf() with sysfs_emit() scsi: bfa: Replace snprintf() with sysfs_emit() power: supply: axp20x_battery: properly report current when discharging powerpc: Set crashkernel offset to mid of RMA region PCI: aardvark: Fix support for MSI interrupts iommu/arm-smmu-v3: fix event handling soft lockup usb: ehci: add pci device support for Aspeed platforms PCI: pciehp: Add Qualcomm quirk for Command Completed erratum ipv4: Invalidate neighbour for broadcast address upon address addition dm ioctl: prevent potential spectre v1 gadget drm/amdkfd: make CRAT table missing message informational only scsi: pm8001: Fix pm8001_mpi_task_abort_resp() scsi: aha152x: Fix aha152x_setup() __setup handler return value net/smc: correct settings of RMB window update limit macvtap: advertise link netns via netlink bnxt_en: Eliminate unintended link toggle during FW reset MIPS: fix fortify panic when copying asm exception handlers scsi: libfc: Fix use after free in fc_exch_abts_resp() usb: dwc3: omap: fix "unbalanced disables for smps10_out1" on omap5evm xtensa: fix DTC warning unit_address_format Bluetooth: Fix use after free in hci_send_acl init/main.c: return 1 from handled __setup() functions minix: fix bug when opening a file with O_DIRECT w1: w1_therm: fixes w1_seq for ds28ea00 sensors NFSv4: Protect the state recovery thread against direct reclaim xen: delay xen_hvm_init_time_ops() if kdump is boot on vcpu>=32 clk: Enforce that disjoints limits are invalid SUNRPC/call_alloc: async tasks mustn't block waiting for memory NFS: swap IO handling is slightly different for O_DIRECT IO NFS: swap-out must always use STABLE writes. serial: samsung_tty: do not unlock port->lock for uart_write_wakeup() virtio_console: eliminate anonymous module_init & module_exit jfs: prevent NULL deref in diFree parisc: Fix CPU affinity for Lasi, WAX and Dino chips net: add missing SOF_TIMESTAMPING_OPT_ID support mm: fix race between MADV_FREE reclaim and blkdev direct IO read KVM: arm64: Check arm64_get_bp_hardening_data() didn't return NULL drm/amdgpu: fix off by one in amdgpu_gfx_kiq_acquire() Drivers: hv: vmbus: Fix potential crash on module unload scsi: zorro7xx: Fix a resource leak in zorro7xx_remove_one() net: stmmac: Fix unset max_speed difference between DT and non-DT platforms drm/imx: Fix memory leak in imx_pd_connector_get_modes net: openvswitch: don't send internal clone attribute to the userspace. rxrpc: fix a race in rxrpc_exit_net() qede: confirm skb is allocated before using spi: bcm-qspi: fix MSPI only access with bcm_qspi_exec_mem_op() drbd: Fix five use after free bugs in get_initial_state Revert "mmc: sdhci-xenon: fix annoying 1.8V regulator warning" mmc: renesas_sdhi: don't overwrite TAP settings when HS400 tuning is complete mmmremap.c: avoid pointless invalidate_range_start/end on mremap(old_size=0) mm/mempolicy: fix mpol_new leak in shared_policy_replace x86/pm: Save the MSR validity status at context setup x86/speculation: Restore speculation related MSRs during S3 resume btrfs: fix qgroup reserve overflow the qgroup limit arm64: patch_text: Fixup last cpu should be master ata: sata_dwc_460ex: Fix crash due to OOB write perf: qcom_l2_pmu: fix an incorrect NULL check on list iterator irqchip/gic-v3: Fix GICR_CTLR.RWP polling tools build: Filter out options and warnings not supported by clang tools build: Use $(shell ) instead of `` to get embedded libperl's ccopts dmaengine: Revert "dmaengine: shdma: Fix runtime PM imbalance on error" mm: don't skip swap entry even if zap_details specified arm64: module: remove (NOLOAD) from linker script mm/sparsemem: fix 'mem_section' will never be NULL gcc 12 warning cgroup: Use open-time credentials for process migraton perm checks cgroup: Allocate cgroup_file_ctx for kernfs_open_file->priv cgroup: Use open-time cgroup namespace for process migration perm checks selftests: cgroup: Make cg_create() use 0755 for permission instead of 0644 selftests: cgroup: Test open-time credential usage for migration checks selftests: cgroup: Test open-time cgroup namespace usage for migration checks xfrm: policy: match with both mark and mask on user interfaces drm/amdgpu: Check if fd really is an amdgpu fd. drm/amdkfd: Use drm_priv to pass VM from KFD to amdgpu Linux 4.19.238 Signed-off-by: Greg Kroah-Hartman <gregkh@google.com> Change-Id: I55a3615d2fbf9bde9ac152456701b36a6c9d20b6
1008 lines
25 KiB
C
1008 lines
25 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Functions related to sysfs handling
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
#include <linux/bio.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/blktrace_api.h>
|
|
#include <linux/blk-mq.h>
|
|
#include <linux/blk-cgroup.h>
|
|
|
|
#include "blk.h"
|
|
#include "blk-mq.h"
|
|
#include "blk-mq-debugfs.h"
|
|
#include "blk-wbt.h"
|
|
|
|
struct queue_sysfs_entry {
|
|
struct attribute attr;
|
|
ssize_t (*show)(struct request_queue *, char *);
|
|
ssize_t (*store)(struct request_queue *, const char *, size_t);
|
|
};
|
|
|
|
static ssize_t
|
|
queue_var_show(unsigned long var, char *page)
|
|
{
|
|
return sprintf(page, "%lu\n", var);
|
|
}
|
|
|
|
static ssize_t
|
|
queue_var_store(unsigned long *var, const char *page, size_t count)
|
|
{
|
|
int err;
|
|
unsigned long v;
|
|
|
|
err = kstrtoul(page, 10, &v);
|
|
if (err || v > UINT_MAX)
|
|
return -EINVAL;
|
|
|
|
*var = v;
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t queue_var_store64(s64 *var, const char *page)
|
|
{
|
|
int err;
|
|
s64 v;
|
|
|
|
err = kstrtos64(page, 10, &v);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
*var = v;
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t queue_requests_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(q->nr_requests, (page));
|
|
}
|
|
|
|
static ssize_t
|
|
queue_requests_store(struct request_queue *q, const char *page, size_t count)
|
|
{
|
|
unsigned long nr;
|
|
int ret, err;
|
|
|
|
if (!q->request_fn && !q->mq_ops)
|
|
return -EINVAL;
|
|
|
|
ret = queue_var_store(&nr, page, count);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (nr < BLKDEV_MIN_RQ)
|
|
nr = BLKDEV_MIN_RQ;
|
|
|
|
if (q->request_fn)
|
|
err = blk_update_nr_requests(q, nr);
|
|
else
|
|
err = blk_mq_update_nr_requests(q, nr);
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t queue_ra_show(struct request_queue *q, char *page)
|
|
{
|
|
unsigned long ra_kb = q->backing_dev_info->ra_pages <<
|
|
(PAGE_SHIFT - 10);
|
|
|
|
return queue_var_show(ra_kb, (page));
|
|
}
|
|
|
|
static ssize_t
|
|
queue_ra_store(struct request_queue *q, const char *page, size_t count)
|
|
{
|
|
unsigned long ra_kb;
|
|
ssize_t ret = queue_var_store(&ra_kb, page, count);
|
|
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
q->backing_dev_info->ra_pages = ra_kb >> (PAGE_SHIFT - 10);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
|
|
{
|
|
int max_sectors_kb = queue_max_sectors(q) >> 1;
|
|
|
|
return queue_var_show(max_sectors_kb, (page));
|
|
}
|
|
|
|
static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(queue_max_segments(q), (page));
|
|
}
|
|
|
|
static ssize_t queue_max_discard_segments_show(struct request_queue *q,
|
|
char *page)
|
|
{
|
|
return queue_var_show(queue_max_discard_segments(q), (page));
|
|
}
|
|
|
|
static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(q->limits.max_integrity_segments, (page));
|
|
}
|
|
|
|
static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
|
|
{
|
|
if (blk_queue_cluster(q))
|
|
return queue_var_show(queue_max_segment_size(q), (page));
|
|
|
|
return queue_var_show(PAGE_SIZE, (page));
|
|
}
|
|
|
|
static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(queue_logical_block_size(q), page);
|
|
}
|
|
|
|
static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(queue_physical_block_size(q), page);
|
|
}
|
|
|
|
static ssize_t queue_chunk_sectors_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(q->limits.chunk_sectors, page);
|
|
}
|
|
|
|
static ssize_t queue_io_min_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(queue_io_min(q), page);
|
|
}
|
|
|
|
static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(queue_io_opt(q), page);
|
|
}
|
|
|
|
static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(q->limits.discard_granularity, page);
|
|
}
|
|
|
|
static ssize_t queue_discard_max_hw_show(struct request_queue *q, char *page)
|
|
{
|
|
|
|
return sprintf(page, "%llu\n",
|
|
(unsigned long long)q->limits.max_hw_discard_sectors << 9);
|
|
}
|
|
|
|
static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
|
|
{
|
|
return sprintf(page, "%llu\n",
|
|
(unsigned long long)q->limits.max_discard_sectors << 9);
|
|
}
|
|
|
|
static ssize_t queue_discard_max_store(struct request_queue *q,
|
|
const char *page, size_t count)
|
|
{
|
|
unsigned long max_discard;
|
|
ssize_t ret = queue_var_store(&max_discard, page, count);
|
|
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (max_discard & (q->limits.discard_granularity - 1))
|
|
return -EINVAL;
|
|
|
|
max_discard >>= 9;
|
|
if (max_discard > UINT_MAX)
|
|
return -EINVAL;
|
|
|
|
if (max_discard > q->limits.max_hw_discard_sectors)
|
|
max_discard = q->limits.max_hw_discard_sectors;
|
|
|
|
q->limits.max_discard_sectors = max_discard;
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(0, page);
|
|
}
|
|
|
|
static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
|
|
{
|
|
return sprintf(page, "%llu\n",
|
|
(unsigned long long)q->limits.max_write_same_sectors << 9);
|
|
}
|
|
|
|
static ssize_t queue_write_zeroes_max_show(struct request_queue *q, char *page)
|
|
{
|
|
return sprintf(page, "%llu\n",
|
|
(unsigned long long)q->limits.max_write_zeroes_sectors << 9);
|
|
}
|
|
|
|
static ssize_t
|
|
queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
|
|
{
|
|
unsigned long max_sectors_kb,
|
|
max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
|
|
page_kb = 1 << (PAGE_SHIFT - 10);
|
|
ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
|
|
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
max_hw_sectors_kb = min_not_zero(max_hw_sectors_kb, (unsigned long)
|
|
q->limits.max_dev_sectors >> 1);
|
|
|
|
if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
|
|
return -EINVAL;
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
q->limits.max_sectors = max_sectors_kb << 1;
|
|
q->backing_dev_info->io_pages = max_sectors_kb >> (PAGE_SHIFT - 10);
|
|
spin_unlock_irq(q->queue_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
|
|
{
|
|
int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
|
|
|
|
return queue_var_show(max_hw_sectors_kb, (page));
|
|
}
|
|
|
|
#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
|
|
static ssize_t \
|
|
queue_show_##name(struct request_queue *q, char *page) \
|
|
{ \
|
|
int bit; \
|
|
bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
|
|
return queue_var_show(neg ? !bit : bit, page); \
|
|
} \
|
|
static ssize_t \
|
|
queue_store_##name(struct request_queue *q, const char *page, size_t count) \
|
|
{ \
|
|
unsigned long val; \
|
|
ssize_t ret; \
|
|
ret = queue_var_store(&val, page, count); \
|
|
if (ret < 0) \
|
|
return ret; \
|
|
if (neg) \
|
|
val = !val; \
|
|
\
|
|
if (val) \
|
|
blk_queue_flag_set(QUEUE_FLAG_##flag, q); \
|
|
else \
|
|
blk_queue_flag_clear(QUEUE_FLAG_##flag, q); \
|
|
return ret; \
|
|
}
|
|
|
|
QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
|
|
QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
|
|
QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
|
|
#undef QUEUE_SYSFS_BIT_FNS
|
|
|
|
static ssize_t queue_zoned_show(struct request_queue *q, char *page)
|
|
{
|
|
switch (blk_queue_zoned_model(q)) {
|
|
case BLK_ZONED_HA:
|
|
return sprintf(page, "host-aware\n");
|
|
case BLK_ZONED_HM:
|
|
return sprintf(page, "host-managed\n");
|
|
default:
|
|
return sprintf(page, "none\n");
|
|
}
|
|
}
|
|
|
|
static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show((blk_queue_nomerges(q) << 1) |
|
|
blk_queue_noxmerges(q), page);
|
|
}
|
|
|
|
static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
|
|
size_t count)
|
|
{
|
|
unsigned long nm;
|
|
ssize_t ret = queue_var_store(&nm, page, count);
|
|
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
|
|
queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
|
|
if (nm == 2)
|
|
queue_flag_set(QUEUE_FLAG_NOMERGES, q);
|
|
else if (nm)
|
|
queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
|
|
spin_unlock_irq(q->queue_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
|
|
{
|
|
bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
|
|
bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
|
|
|
|
return queue_var_show(set << force, page);
|
|
}
|
|
|
|
static ssize_t
|
|
queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
|
|
{
|
|
ssize_t ret = -EINVAL;
|
|
#ifdef CONFIG_SMP
|
|
unsigned long val;
|
|
|
|
ret = queue_var_store(&val, page, count);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
if (val == 2) {
|
|
queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
|
|
queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
|
|
} else if (val == 1) {
|
|
queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
|
|
queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
|
|
} else if (val == 0) {
|
|
queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
|
|
queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
|
|
}
|
|
spin_unlock_irq(q->queue_lock);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t queue_poll_delay_show(struct request_queue *q, char *page)
|
|
{
|
|
int val;
|
|
|
|
if (q->poll_nsec == -1)
|
|
val = -1;
|
|
else
|
|
val = q->poll_nsec / 1000;
|
|
|
|
return sprintf(page, "%d\n", val);
|
|
}
|
|
|
|
static ssize_t queue_poll_delay_store(struct request_queue *q, const char *page,
|
|
size_t count)
|
|
{
|
|
int err, val;
|
|
|
|
if (!q->mq_ops || !q->mq_ops->poll)
|
|
return -EINVAL;
|
|
|
|
err = kstrtoint(page, 10, &val);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
if (val == -1)
|
|
q->poll_nsec = -1;
|
|
else
|
|
q->poll_nsec = val * 1000;
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t queue_poll_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(test_bit(QUEUE_FLAG_POLL, &q->queue_flags), page);
|
|
}
|
|
|
|
static ssize_t queue_poll_store(struct request_queue *q, const char *page,
|
|
size_t count)
|
|
{
|
|
unsigned long poll_on;
|
|
ssize_t ret;
|
|
|
|
if (!q->mq_ops || !q->mq_ops->poll)
|
|
return -EINVAL;
|
|
|
|
ret = queue_var_store(&poll_on, page, count);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (poll_on)
|
|
blk_queue_flag_set(QUEUE_FLAG_POLL, q);
|
|
else
|
|
blk_queue_flag_clear(QUEUE_FLAG_POLL, q);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t queue_wb_lat_show(struct request_queue *q, char *page)
|
|
{
|
|
if (!wbt_rq_qos(q))
|
|
return -EINVAL;
|
|
|
|
return sprintf(page, "%llu\n", div_u64(wbt_get_min_lat(q), 1000));
|
|
}
|
|
|
|
static ssize_t queue_wb_lat_store(struct request_queue *q, const char *page,
|
|
size_t count)
|
|
{
|
|
struct rq_qos *rqos;
|
|
ssize_t ret;
|
|
s64 val;
|
|
|
|
ret = queue_var_store64(&val, page);
|
|
if (ret < 0)
|
|
return ret;
|
|
if (val < -1)
|
|
return -EINVAL;
|
|
|
|
rqos = wbt_rq_qos(q);
|
|
if (!rqos) {
|
|
ret = wbt_init(q);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
if (val == -1)
|
|
val = wbt_default_latency_nsec(q);
|
|
else if (val >= 0)
|
|
val *= 1000ULL;
|
|
|
|
/*
|
|
* Ensure that the queue is idled, in case the latency update
|
|
* ends up either enabling or disabling wbt completely. We can't
|
|
* have IO inflight if that happens.
|
|
*/
|
|
if (q->mq_ops) {
|
|
blk_mq_freeze_queue(q);
|
|
blk_mq_quiesce_queue(q);
|
|
} else
|
|
blk_queue_bypass_start(q);
|
|
|
|
wbt_set_min_lat(q, val);
|
|
wbt_update_limits(q);
|
|
|
|
if (q->mq_ops) {
|
|
blk_mq_unquiesce_queue(q);
|
|
blk_mq_unfreeze_queue(q);
|
|
} else
|
|
blk_queue_bypass_end(q);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t queue_wc_show(struct request_queue *q, char *page)
|
|
{
|
|
if (test_bit(QUEUE_FLAG_WC, &q->queue_flags))
|
|
return sprintf(page, "write back\n");
|
|
|
|
return sprintf(page, "write through\n");
|
|
}
|
|
|
|
static ssize_t queue_wc_store(struct request_queue *q, const char *page,
|
|
size_t count)
|
|
{
|
|
int set = -1;
|
|
|
|
if (!strncmp(page, "write back", 10))
|
|
set = 1;
|
|
else if (!strncmp(page, "write through", 13) ||
|
|
!strncmp(page, "none", 4))
|
|
set = 0;
|
|
|
|
if (set == -1)
|
|
return -EINVAL;
|
|
|
|
if (set)
|
|
blk_queue_flag_set(QUEUE_FLAG_WC, q);
|
|
else
|
|
blk_queue_flag_clear(QUEUE_FLAG_WC, q);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t queue_fua_show(struct request_queue *q, char *page)
|
|
{
|
|
return sprintf(page, "%u\n", test_bit(QUEUE_FLAG_FUA, &q->queue_flags));
|
|
}
|
|
|
|
static ssize_t queue_dax_show(struct request_queue *q, char *page)
|
|
{
|
|
return queue_var_show(blk_queue_dax(q), page);
|
|
}
|
|
|
|
static struct queue_sysfs_entry queue_requests_entry = {
|
|
.attr = {.name = "nr_requests", .mode = 0644 },
|
|
.show = queue_requests_show,
|
|
.store = queue_requests_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_ra_entry = {
|
|
.attr = {.name = "read_ahead_kb", .mode = 0644 },
|
|
.show = queue_ra_show,
|
|
.store = queue_ra_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_max_sectors_entry = {
|
|
.attr = {.name = "max_sectors_kb", .mode = 0644 },
|
|
.show = queue_max_sectors_show,
|
|
.store = queue_max_sectors_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
|
|
.attr = {.name = "max_hw_sectors_kb", .mode = 0444 },
|
|
.show = queue_max_hw_sectors_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_max_segments_entry = {
|
|
.attr = {.name = "max_segments", .mode = 0444 },
|
|
.show = queue_max_segments_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_max_discard_segments_entry = {
|
|
.attr = {.name = "max_discard_segments", .mode = 0444 },
|
|
.show = queue_max_discard_segments_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
|
|
.attr = {.name = "max_integrity_segments", .mode = 0444 },
|
|
.show = queue_max_integrity_segments_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_max_segment_size_entry = {
|
|
.attr = {.name = "max_segment_size", .mode = 0444 },
|
|
.show = queue_max_segment_size_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_iosched_entry = {
|
|
.attr = {.name = "scheduler", .mode = 0644 },
|
|
.show = elv_iosched_show,
|
|
.store = elv_iosched_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_hw_sector_size_entry = {
|
|
.attr = {.name = "hw_sector_size", .mode = 0444 },
|
|
.show = queue_logical_block_size_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_logical_block_size_entry = {
|
|
.attr = {.name = "logical_block_size", .mode = 0444 },
|
|
.show = queue_logical_block_size_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_physical_block_size_entry = {
|
|
.attr = {.name = "physical_block_size", .mode = 0444 },
|
|
.show = queue_physical_block_size_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_chunk_sectors_entry = {
|
|
.attr = {.name = "chunk_sectors", .mode = 0444 },
|
|
.show = queue_chunk_sectors_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_io_min_entry = {
|
|
.attr = {.name = "minimum_io_size", .mode = 0444 },
|
|
.show = queue_io_min_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_io_opt_entry = {
|
|
.attr = {.name = "optimal_io_size", .mode = 0444 },
|
|
.show = queue_io_opt_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_discard_granularity_entry = {
|
|
.attr = {.name = "discard_granularity", .mode = 0444 },
|
|
.show = queue_discard_granularity_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_discard_max_hw_entry = {
|
|
.attr = {.name = "discard_max_hw_bytes", .mode = 0444 },
|
|
.show = queue_discard_max_hw_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_discard_max_entry = {
|
|
.attr = {.name = "discard_max_bytes", .mode = 0644 },
|
|
.show = queue_discard_max_show,
|
|
.store = queue_discard_max_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
|
|
.attr = {.name = "discard_zeroes_data", .mode = 0444 },
|
|
.show = queue_discard_zeroes_data_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_write_same_max_entry = {
|
|
.attr = {.name = "write_same_max_bytes", .mode = 0444 },
|
|
.show = queue_write_same_max_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_write_zeroes_max_entry = {
|
|
.attr = {.name = "write_zeroes_max_bytes", .mode = 0444 },
|
|
.show = queue_write_zeroes_max_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_nonrot_entry = {
|
|
.attr = {.name = "rotational", .mode = 0644 },
|
|
.show = queue_show_nonrot,
|
|
.store = queue_store_nonrot,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_zoned_entry = {
|
|
.attr = {.name = "zoned", .mode = 0444 },
|
|
.show = queue_zoned_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_nomerges_entry = {
|
|
.attr = {.name = "nomerges", .mode = 0644 },
|
|
.show = queue_nomerges_show,
|
|
.store = queue_nomerges_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_rq_affinity_entry = {
|
|
.attr = {.name = "rq_affinity", .mode = 0644 },
|
|
.show = queue_rq_affinity_show,
|
|
.store = queue_rq_affinity_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_iostats_entry = {
|
|
.attr = {.name = "iostats", .mode = 0644 },
|
|
.show = queue_show_iostats,
|
|
.store = queue_store_iostats,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_random_entry = {
|
|
.attr = {.name = "add_random", .mode = 0644 },
|
|
.show = queue_show_random,
|
|
.store = queue_store_random,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_poll_entry = {
|
|
.attr = {.name = "io_poll", .mode = 0644 },
|
|
.show = queue_poll_show,
|
|
.store = queue_poll_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_poll_delay_entry = {
|
|
.attr = {.name = "io_poll_delay", .mode = 0644 },
|
|
.show = queue_poll_delay_show,
|
|
.store = queue_poll_delay_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_wc_entry = {
|
|
.attr = {.name = "write_cache", .mode = 0644 },
|
|
.show = queue_wc_show,
|
|
.store = queue_wc_store,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_fua_entry = {
|
|
.attr = {.name = "fua", .mode = 0444 },
|
|
.show = queue_fua_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_dax_entry = {
|
|
.attr = {.name = "dax", .mode = 0444 },
|
|
.show = queue_dax_show,
|
|
};
|
|
|
|
static struct queue_sysfs_entry queue_wb_lat_entry = {
|
|
.attr = {.name = "wbt_lat_usec", .mode = 0644 },
|
|
.show = queue_wb_lat_show,
|
|
.store = queue_wb_lat_store,
|
|
};
|
|
|
|
#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
|
|
static struct queue_sysfs_entry throtl_sample_time_entry = {
|
|
.attr = {.name = "throttle_sample_time", .mode = 0644 },
|
|
.show = blk_throtl_sample_time_show,
|
|
.store = blk_throtl_sample_time_store,
|
|
};
|
|
#endif
|
|
|
|
static struct attribute *default_attrs[] = {
|
|
&queue_requests_entry.attr,
|
|
&queue_ra_entry.attr,
|
|
&queue_max_hw_sectors_entry.attr,
|
|
&queue_max_sectors_entry.attr,
|
|
&queue_max_segments_entry.attr,
|
|
&queue_max_discard_segments_entry.attr,
|
|
&queue_max_integrity_segments_entry.attr,
|
|
&queue_max_segment_size_entry.attr,
|
|
&queue_iosched_entry.attr,
|
|
&queue_hw_sector_size_entry.attr,
|
|
&queue_logical_block_size_entry.attr,
|
|
&queue_physical_block_size_entry.attr,
|
|
&queue_chunk_sectors_entry.attr,
|
|
&queue_io_min_entry.attr,
|
|
&queue_io_opt_entry.attr,
|
|
&queue_discard_granularity_entry.attr,
|
|
&queue_discard_max_entry.attr,
|
|
&queue_discard_max_hw_entry.attr,
|
|
&queue_discard_zeroes_data_entry.attr,
|
|
&queue_write_same_max_entry.attr,
|
|
&queue_write_zeroes_max_entry.attr,
|
|
&queue_nonrot_entry.attr,
|
|
&queue_zoned_entry.attr,
|
|
&queue_nomerges_entry.attr,
|
|
&queue_rq_affinity_entry.attr,
|
|
&queue_iostats_entry.attr,
|
|
&queue_random_entry.attr,
|
|
&queue_poll_entry.attr,
|
|
&queue_wc_entry.attr,
|
|
&queue_fua_entry.attr,
|
|
&queue_dax_entry.attr,
|
|
&queue_wb_lat_entry.attr,
|
|
&queue_poll_delay_entry.attr,
|
|
#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
|
|
&throtl_sample_time_entry.attr,
|
|
#endif
|
|
NULL,
|
|
};
|
|
|
|
#define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
|
|
|
|
static ssize_t
|
|
queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
|
|
{
|
|
struct queue_sysfs_entry *entry = to_queue(attr);
|
|
struct request_queue *q =
|
|
container_of(kobj, struct request_queue, kobj);
|
|
ssize_t res;
|
|
|
|
if (!entry->show)
|
|
return -EIO;
|
|
mutex_lock(&q->sysfs_lock);
|
|
if (blk_queue_dying(q)) {
|
|
mutex_unlock(&q->sysfs_lock);
|
|
return -ENOENT;
|
|
}
|
|
res = entry->show(q, page);
|
|
mutex_unlock(&q->sysfs_lock);
|
|
return res;
|
|
}
|
|
|
|
static ssize_t
|
|
queue_attr_store(struct kobject *kobj, struct attribute *attr,
|
|
const char *page, size_t length)
|
|
{
|
|
struct queue_sysfs_entry *entry = to_queue(attr);
|
|
struct request_queue *q;
|
|
ssize_t res;
|
|
|
|
if (!entry->store)
|
|
return -EIO;
|
|
|
|
q = container_of(kobj, struct request_queue, kobj);
|
|
mutex_lock(&q->sysfs_lock);
|
|
if (blk_queue_dying(q)) {
|
|
mutex_unlock(&q->sysfs_lock);
|
|
return -ENOENT;
|
|
}
|
|
res = entry->store(q, page, length);
|
|
mutex_unlock(&q->sysfs_lock);
|
|
return res;
|
|
}
|
|
|
|
static void blk_free_queue_rcu(struct rcu_head *rcu_head)
|
|
{
|
|
struct request_queue *q = container_of(rcu_head, struct request_queue,
|
|
rcu_head);
|
|
kmem_cache_free(blk_requestq_cachep, q);
|
|
}
|
|
|
|
/**
|
|
* __blk_release_queue - release a request queue when it is no longer needed
|
|
* @work: pointer to the release_work member of the request queue to be released
|
|
*
|
|
* Description:
|
|
* blk_release_queue is the counterpart of blk_init_queue(). It should be
|
|
* called when a request queue is being released; typically when a block
|
|
* device is being de-registered. Its primary task it to free the queue
|
|
* itself.
|
|
*
|
|
* Notes:
|
|
* The low level driver must have finished any outstanding requests first
|
|
* via blk_cleanup_queue().
|
|
*
|
|
* Although blk_release_queue() may be called with preemption disabled,
|
|
* __blk_release_queue() may sleep.
|
|
*/
|
|
static void __blk_release_queue(struct work_struct *work)
|
|
{
|
|
struct request_queue *q = container_of(work, typeof(*q), release_work);
|
|
|
|
if (test_bit(QUEUE_FLAG_POLL_STATS, &q->queue_flags))
|
|
blk_stat_remove_callback(q, q->poll_cb);
|
|
blk_stat_free_callback(q->poll_cb);
|
|
|
|
if (!blk_queue_dead(q)) {
|
|
/*
|
|
* Last reference was dropped without having called
|
|
* blk_cleanup_queue().
|
|
*/
|
|
WARN_ONCE(blk_queue_init_done(q),
|
|
"request queue %p has been registered but blk_cleanup_queue() has not been called for that queue\n",
|
|
q);
|
|
blk_exit_queue(q);
|
|
}
|
|
|
|
WARN(blk_queue_root_blkg(q),
|
|
"request queue %p is being released but it has not yet been removed from the blkcg controller\n",
|
|
q);
|
|
|
|
blk_free_queue_stats(q->stats);
|
|
|
|
if (q->mq_ops)
|
|
cancel_delayed_work_sync(&q->requeue_work);
|
|
|
|
blk_exit_rl(q, &q->root_rl);
|
|
|
|
if (q->queue_tags)
|
|
__blk_queue_free_tags(q);
|
|
|
|
if (!q->mq_ops) {
|
|
if (q->exit_rq_fn)
|
|
q->exit_rq_fn(q, q->fq->flush_rq);
|
|
blk_free_flush_queue(q->fq);
|
|
} else {
|
|
blk_mq_release(q);
|
|
}
|
|
|
|
blk_trace_shutdown(q);
|
|
|
|
if (q->mq_ops)
|
|
blk_mq_debugfs_unregister(q);
|
|
|
|
bioset_exit(&q->bio_split);
|
|
|
|
ida_simple_remove(&blk_queue_ida, q->id);
|
|
call_rcu(&q->rcu_head, blk_free_queue_rcu);
|
|
}
|
|
|
|
static void blk_release_queue(struct kobject *kobj)
|
|
{
|
|
struct request_queue *q =
|
|
container_of(kobj, struct request_queue, kobj);
|
|
|
|
INIT_WORK(&q->release_work, __blk_release_queue);
|
|
schedule_work(&q->release_work);
|
|
}
|
|
|
|
static const struct sysfs_ops queue_sysfs_ops = {
|
|
.show = queue_attr_show,
|
|
.store = queue_attr_store,
|
|
};
|
|
|
|
struct kobj_type blk_queue_ktype = {
|
|
.sysfs_ops = &queue_sysfs_ops,
|
|
.default_attrs = default_attrs,
|
|
.release = blk_release_queue,
|
|
};
|
|
|
|
/**
|
|
* blk_register_queue - register a block layer queue with sysfs
|
|
* @disk: Disk of which the request queue should be registered with sysfs.
|
|
*/
|
|
int blk_register_queue(struct gendisk *disk)
|
|
{
|
|
int ret;
|
|
struct device *dev = disk_to_dev(disk);
|
|
struct request_queue *q = disk->queue;
|
|
|
|
if (WARN_ON(!q))
|
|
return -ENXIO;
|
|
|
|
WARN_ONCE(blk_queue_registered(q),
|
|
"%s is registering an already registered queue\n",
|
|
kobject_name(&dev->kobj));
|
|
queue_flag_set_unlocked(QUEUE_FLAG_REGISTERED, q);
|
|
|
|
/*
|
|
* SCSI probing may synchronously create and destroy a lot of
|
|
* request_queues for non-existent devices. Shutting down a fully
|
|
* functional queue takes measureable wallclock time as RCU grace
|
|
* periods are involved. To avoid excessive latency in these
|
|
* cases, a request_queue starts out in a degraded mode which is
|
|
* faster to shut down and is made fully functional here as
|
|
* request_queues for non-existent devices never get registered.
|
|
*/
|
|
if (!blk_queue_init_done(q)) {
|
|
queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
|
|
percpu_ref_switch_to_percpu(&q->q_usage_counter);
|
|
blk_queue_bypass_end(q);
|
|
}
|
|
|
|
ret = blk_trace_init_sysfs(dev);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* Prevent changes through sysfs until registration is completed. */
|
|
mutex_lock(&q->sysfs_lock);
|
|
|
|
ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
|
|
if (ret < 0) {
|
|
blk_trace_remove_sysfs(dev);
|
|
goto unlock;
|
|
}
|
|
|
|
if (q->mq_ops) {
|
|
__blk_mq_register_dev(dev, q);
|
|
blk_mq_debugfs_register(q);
|
|
}
|
|
|
|
kobject_uevent(&q->kobj, KOBJ_ADD);
|
|
|
|
wbt_enable_default(q);
|
|
|
|
blk_throtl_register_queue(q);
|
|
|
|
if (q->request_fn || (q->mq_ops && q->elevator)) {
|
|
ret = elv_register_queue(q);
|
|
if (ret) {
|
|
mutex_unlock(&q->sysfs_lock);
|
|
kobject_uevent(&q->kobj, KOBJ_REMOVE);
|
|
kobject_del(&q->kobj);
|
|
blk_trace_remove_sysfs(dev);
|
|
kobject_put(&dev->kobj);
|
|
return ret;
|
|
}
|
|
}
|
|
ret = 0;
|
|
unlock:
|
|
mutex_unlock(&q->sysfs_lock);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(blk_register_queue);
|
|
|
|
/**
|
|
* blk_unregister_queue - counterpart of blk_register_queue()
|
|
* @disk: Disk of which the request queue should be unregistered from sysfs.
|
|
*
|
|
* Note: the caller is responsible for guaranteeing that this function is called
|
|
* after blk_register_queue() has finished.
|
|
*/
|
|
void blk_unregister_queue(struct gendisk *disk)
|
|
{
|
|
struct request_queue *q = disk->queue;
|
|
|
|
if (WARN_ON(!q))
|
|
return;
|
|
|
|
/* Return early if disk->queue was never registered. */
|
|
if (!blk_queue_registered(q))
|
|
return;
|
|
|
|
/*
|
|
* Since sysfs_remove_dir() prevents adding new directory entries
|
|
* before removal of existing entries starts, protect against
|
|
* concurrent elv_iosched_store() calls.
|
|
*/
|
|
mutex_lock(&q->sysfs_lock);
|
|
|
|
blk_queue_flag_clear(QUEUE_FLAG_REGISTERED, q);
|
|
|
|
/*
|
|
* Remove the sysfs attributes before unregistering the queue data
|
|
* structures that can be modified through sysfs.
|
|
*/
|
|
if (q->mq_ops)
|
|
blk_mq_unregister_dev(disk_to_dev(disk), q);
|
|
mutex_unlock(&q->sysfs_lock);
|
|
|
|
blk_trace_remove_sysfs(disk_to_dev(disk));
|
|
|
|
mutex_lock(&q->sysfs_lock);
|
|
if (q->request_fn || (q->mq_ops && q->elevator))
|
|
elv_unregister_queue(q);
|
|
mutex_unlock(&q->sysfs_lock);
|
|
|
|
/* Now that we've deleted all child objects, we can delete the queue. */
|
|
kobject_uevent(&q->kobj, KOBJ_REMOVE);
|
|
kobject_del(&q->kobj);
|
|
|
|
kobject_put(&disk_to_dev(disk)->kobj);
|
|
}
|