5.15.154-rc1 review
Subsystems (8)
Greg Kroah-Hartman
maintainerPATCH 126/690 ALSA: hda/realtek - Fix headset Mic no show at resume back for Lenovo ALC897 platform
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Kailang Yang <[email protected]>
commit d397b6e56151099cf3b1f7bfccb204a6a8591720 upstream.
Headset Mic will no show at resume back.
This patch will fix this issue.
--- sound/pci/hda/patch_realtek.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
sound/pci/hda/patch_realtek.c +5 -2
@@ -10783,8 +10783,7 @@ static void alc897_hp_automute_hook(strusnd_hda_gen_hp_automute (codec, jack); vref = spec->gen.hp_jack_present ? (PIN_HP |AC_PINCTL_VREF_100 ) :PIN_HP ; -snd_hda_codec_write (codec,0x1b ,0 ,AC_VERB_SET_PIN_WIDGET_CONTROL , - vref); +snd_hda_set_pin_ctl (codec,0x1b , vref); } static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
@@ -10793,6 +10792,10 @@ static void alc897_fixup_lenovo_headset_struct alc_spec *spec = codec->spec;if (action ==HDA_FIXUP_ACT_PRE_PROBE ) { spec->gen.hp_automute_hook = alc897_hp_automute_hook; + spec->no_shutup_pins =1 ; + } +if (action ==HDA_FIXUP_ACT_PROBE ) { +snd_hda_set_pin_ctl_cache (codec,0x1a ,PIN_IN |AC_PINCTL_VREF_100 ); } }
Greg Kroah-Hartman
maintainerPATCH 127/690 USB: usb-storage: Prevent divide-by-0 error in isd200_ata_command
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Alan Stern <[email protected]>
commit 014bcf41d946b36a8f0b8e9b5d9529efbb822f49 upstream.
The isd200 sub-driver in usb-storage uses the HEADS and SECTORS values in the ATA ID information to calculate cylinder and head values when creating a CDB for READ or WRITE commands. The calculation involves division and modulus operations, which will cause a crash if either of these values is 0. While this never happens with a genuine device, it could happen with a flawed or subversive emulation, as reported by the syzbot fuzzer.
Protect against this possibility by refusing to bind to the device if either the ATA_ID_HEADS or ATA_ID_SECTORS value in the device's ID information is 0. This requires isd200_Initialization() to return a negative error code when initialization fails; currently it always returns 0 (even when there is an error).
--- drivers/usb/storage/isd200.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-)
drivers/usb/storage/isd200.c +18 -5
@@ -1105,7 +1105,7 @@ static void isd200_dump_driveid(struct ustatic int isd200_get_inquiry_data (struct us_data *us ) {struct isd200_info *info = (struct isd200_info *)us->extra; -int retStatus =ISD200_GOOD ; +int retStatus;u16 *id = info->id;usb_stor_dbg (us,"Entering isd200_get_inquiry_data\n" );
@@ -1137,6 +1137,13 @@ static int isd200_get_inquiry_data( struisd200_fix_driveid (id);isd200_dump_driveid (us, id); +/* Prevent division by 0 in isd200_scsi_to_ata() */ +if (id[ATA_ID_HEADS ] ==0 || id[ATA_ID_SECTORS ] ==0 ) { +usb_stor_dbg (us," Invalid ATA Identify data\n" ); + retStatus =ISD200_ERROR ; + goto Done; + } +memset (&info->InquiryData,0 ,sizeof (info->InquiryData));/* Standard IDE interface only supports disks */
@@ -1202,6 +1209,7 @@ static int isd200_get_inquiry_data( stru } } + Done:usb_stor_dbg (us,"Leaving isd200_get_inquiry_data %08X\n" , retStatus);return (retStatus);
@@ -1481,22 +1489,27 @@ static int isd200_init_info(struct us_dastatic int isd200_Initialization (struct us_data *us) { +int rc =0 ; +usb_stor_dbg (us,"ISD200 Initialization...\n" );/* Initialize ISD200 info struct */ -if (isd200_init_info (us) ==ISD200_ERROR ) { +if (isd200_init_info (us) <0 ) {usb_stor_dbg (us,"ERROR Initializing ISD200 Info struct\n" ); + rc = -ENOMEM ; }else {/* Get device specific data */ -if (isd200_get_inquiry_data (us) !=ISD200_GOOD ) +if (isd200_get_inquiry_data (us) !=ISD200_GOOD ) {usb_stor_dbg (us,"ISD200 Initialization Failure\n" ); -else + rc = -EINVAL ; + }else {usb_stor_dbg (us,"ISD200 Initialization complete\n" ); + } } -return 0 ; +return rc; }
Greg Kroah-Hartman
maintainerPATCH 128/690 usb: gadget: ncm: Fix handling of zero block length packets
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Krishna Kurapati <[email protected]>
commit f90ce1e04cbcc76639d6cba0fdbd820cd80b3c70 upstream.
While connecting to a Linux host with CDC_NCM_NTB_DEF_SIZE_TX set to 65536, it has been observed that we receive short packets, which come at interval of 5-10 seconds sometimes and have block length zero but still contain 1-2 valid datagrams present.
According to the NCM spec:
"If wBlockLength = 0x0000, the block is terminated by a short packet. In this case, the USB transfer must still be shorter than dwNtbInMaxSize or dwNtbOutMaxSize. If exactly dwNtbInMaxSize or dwNtbOutMaxSize bytes are sent, and the size is a multiple of wMaxPacketSize for the given pipe, then no ZLP shall be sent.
wBlockLength= 0x0000 must be used with extreme care, because of the possibility that the host and device may get out of sync, and because of test issues.
wBlockLength = 0x0000 allows the sender to reduce latency by starting to send a very large NTB, and then shortening it when the sender discovers that there’s not sufficient data to justify sending a large NTB"
However, there is a potential issue with the current implementation, as it checks for the occurrence of multiple NTBs in a single giveback by verifying if the leftover bytes to be processed is zero or not. If the block length reads zero, we would process the same NTB infintely because the leftover bytes is never zero and it leads to a crash. Fix this by bailing out if block length reads zero.
--- drivers/usb/gadget/function/f_ncm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/usb/gadget/function/f_ncm.c +1 -1
@@ -1352,7 +1352,7 @@ parse_ntb:if (to_process ==1 && (*(unsigned char *)(ntb_ptr + block_len) ==0x00 )) { to_process--; - }else if (to_process >0 ) { + }else if ((to_process >0 ) && (block_len !=0 )) { ntb_ptr = (unsigned char *)(ntb_ptr + block_len); goto parse_ntb; }
Greg Kroah-Hartman
maintainerPATCH 129/690 usb: port: Dont try to peer unused USB ports based on location
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Mathias Nyman <[email protected]>
commit 69c63350e573367f9c8594162288cffa8a26d0d1 upstream.
Unused USB ports may have bogus location data in ACPI PLD tables. This causes port peering failures as these unused USB2 and USB3 ports location may match.
Due to these failures the driver prints a
"usb: port power management may be unreliable" warning, and unnecessarily blocks port power off during runtime suspend.
This was debugged on a couple DELL systems where the unused ports all returned zeroes in their location data.
Similar bugreports exist for other systems.
Don't try to peer or match ports that have connect type set to USB_PORT_NOT_USED.
--- drivers/usb/core/port.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/usb/core/port.c +3 -2
@@ -450,7 +450,7 @@ static int match_location(struct usb_devstruct usb_hub *peer_hub =usb_hub_to_struct_hub (peer_hdev);struct usb_device *hdev =to_usb_device (port_dev->dev.parent->parent); -if (!peer_hub) +if (!peer_hub || port_dev->connect_type ==USB_PORT_NOT_USED )return 0 ; hcd =bus_to_hcd (hdev->bus);
@@ -461,7 +461,8 @@ static int match_location(struct usb_devfor (port1 =1 ; port1 <= peer_hdev->maxchild; port1++) { peer = peer_hub->ports[port1 -1 ]; -if (peer && peer->location == port_dev->location) { +if (peer && peer->connect_type !=USB_PORT_NOT_USED && + peer->location == port_dev->location) {link_peers_report (port_dev, peer);return 1 ;/* done */ }
Greg Kroah-Hartman
maintainerPATCH 130/690 tty: serial: fsl_lpuart: avoid idle preamble pending if CTS is enabled
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sherry Sun <[email protected]>
commit 74cb7e0355fae9641f825afa389d3fba3b617714 upstream.
If the remote uart device is not connected or not enabled after booting up, the CTS line is high by default. At this time, if we enable the flow control when opening the device(for example, using “stty -F /dev/ttyLP4 crtscts” command), there will be a pending idle preamble(first writing 0 and then writing 1 to UARTCTRL_TE will queue an idle preamble) that cannot be sent out, resulting in the uart port fail to close(waiting for TX empty), so the user space stty will have to wait for a long time or forever.
This is an LPUART IP bug(idle preamble has higher priority than CTS), here add a workaround patch to enable TX CTS after enabling UARTCTRL_TE, so that the idle preamble does not get stuck due to CTS is deasserted.
--- drivers/tty/serial/fsl_lpuart.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/tty/serial/fsl_lpuart.c +5 -2
@@ -2237,9 +2237,12 @@ lpuart32_set_termios(struct uart_port *plpuart32_write (&sport->port, bd,UARTBAUD );lpuart32_serial_setbrg (sport, baud); -lpuart32_write (&sport->port, modem,UARTMODIR ); -lpuart32_write (&sport->port, ctrl,UARTCTRL ); +/* disable CTS before enabling UARTCTRL_TE to avoid pending idle preamble */ +lpuart32_write (&sport->port, modem & ~UARTMODIR_TXCTSE ,UARTMODIR );/* restore control register */ +lpuart32_write (&sport->port, ctrl,UARTCTRL ); +/* re-enable the CTS if needed */ +lpuart32_write (&sport->port, modem,UARTMODIR );if (old && sport->lpuart_dma_rx_use) {if (!lpuart_start_rx_dma (sport))
Greg Kroah-Hartman
maintainerPATCH 131/690 mei: me: add arrow lake point S DID
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Alexander Usyskin <[email protected]>
commit 7a9b9012043e126f6d6f4683e67409312d1b707b upstream.
Add Arrow Lake S device id.
--- drivers/misc/mei/hw-me-regs.h | 1 + drivers/misc/mei/pci-me.c | 1 + 2 files changed, 2 insertions(+)
drivers/misc/mei/hw-me-regs.h +1 -0
@@ -112,6 +112,7 @@#define MEI_DEV_ID_RPL_S 0x7A68/* Raptor Lake Point S */ #define MEI_DEV_ID_MTL_M 0x7E70/* Meteor Lake Point M */ +#define MEI_DEV_ID_ARL_S 0x7F68/* Arrow Lake Point S */ /* * MEI HW Section
drivers/misc/mei/pci-me.c +1 -0
@@ -118,6 +118,7 @@ static const struct pci_device_id mei_me {MEI_PCI_DEVICE(MEI_DEV_ID_RPL_S, MEI_ME_PCH15_CFG)}, {MEI_PCI_DEVICE(MEI_DEV_ID_MTL_M, MEI_ME_PCH15_CFG)}, + {MEI_PCI_DEVICE(MEI_DEV_ID_ARL_S, MEI_ME_PCH15_CFG)},/* required last entry */ {0, }
Greg Kroah-Hartman
maintainerPATCH 132/690 mei: me: add arrow lake point H DID
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Alexander Usyskin <[email protected]>
commit 8436f25802ec028ac7254990893f3e01926d9b79 upstream.
Add Arrow Lake H device id.
--- drivers/misc/mei/hw-me-regs.h | 1 + drivers/misc/mei/pci-me.c | 1 + 2 files changed, 2 insertions(+)
drivers/misc/mei/hw-me-regs.h +1 -0
@@ -113,6 +113,7 @@#define MEI_DEV_ID_MTL_M 0x7E70/* Meteor Lake Point M */ #define MEI_DEV_ID_ARL_S 0x7F68/* Arrow Lake Point S */ +#define MEI_DEV_ID_ARL_H 0x7770/* Arrow Lake Point H */ /* * MEI HW Section
drivers/misc/mei/pci-me.c +1 -0
@@ -119,6 +119,7 @@ static const struct pci_device_id mei_me {MEI_PCI_DEVICE(MEI_DEV_ID_MTL_M, MEI_ME_PCH15_CFG)}, {MEI_PCI_DEVICE(MEI_DEV_ID_ARL_S, MEI_ME_PCH15_CFG)}, + {MEI_PCI_DEVICE(MEI_DEV_ID_ARL_H, MEI_ME_PCH15_CFG)},/* required last entry */ {0, }
Greg Kroah-Hartman
maintainerPATCH 133/690 vt: fix unicode buffer corruption when deleting characters
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Nicolas Pitre <[email protected]>
commit 1581dafaf0d34bc9c428a794a22110d7046d186d upstream.
This is the same issue that was fixed for the VGA text buffer in commit 39cdb68c64d8 ("vt: fix memory overlapping when deleting chars in the buffer"). The cure is also the same i.e. replace memcpy() with memmove() due to the overlaping buffers.
--- drivers/tty/vt/vt.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/tty/vt/vt.c +1 -1
@@ -398,7 +398,7 @@ static void vc_uniscr_delete(struct vc_dchar32_t *ln = uniscr->lines[vc->state.y];unsigned int x = vc->state.x, cols = vc->vc_cols; -memcpy (&ln[x], &ln[x + nr], (cols - x - nr) *sizeof (*ln)); +memmove (&ln[x], &ln[x + nr], (cols - x - nr) *sizeof (*ln));memset32 (&ln[cols - nr],' ' , nr); } }
Greg Kroah-Hartman
maintainerPATCH 134/690 fs/aio: Check IOCB_AIO_RW before the struct aio_kiocb conversion
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Bart Van Assche <[email protected]>
commit 961ebd120565cb60cebe21cb634fbc456022db4a upstream.
The first kiocb_set_cancel_fn() argument may point at a struct kiocb that is not embedded inside struct aio_kiocb. With the current code, depending on the compiler, the req->ki_ctx read happens either before the IOCB_AIO_RW test or after that test. Move the req->ki_ctx read such that it is guaranteed that the IOCB_AIO_RW test happens first.
--- fs/aio.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
fs/aio.c +6 -2
@@ -564,8 +564,8 @@ static int aio_setup_ring(struct kioctxvoid kiocb_set_cancel_fn (struct kiocb *iocb,kiocb_cancel_fn *cancel) { - struct aio_kiocb *req = container_of(iocb, struct aio_kiocb, rw); -struct kioctx *ctx = req->ki_ctx; +struct aio_kiocb *req; +struct kioctx *ctx;unsigned long flags;/*
@@ -575,9 +575,13 @@ void kiocb_set_cancel_fn(struct kiocb *iif (!(iocb->ki_flags &IOCB_AIO_RW ))return ; + req = container_of(iocb, struct aio_kiocb, rw); +if (WARN_ON_ONCE (!list_empty (&req->ki_list)))return ; + ctx = req->ki_ctx; +spin_lock_irqsave (&ctx->ctx_lock, flags);list_add_tail (&req->ki_list, &ctx->active_reqs); req->ki_cancel = cancel;
Greg Kroah-Hartman
maintainerPATCH 135/690 tee: optee: Fix kernel panic caused by incorrect error handling
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sumit Garg <[email protected]>
commit 95915ba4b987cf2b222b0f251280228a1ff977ac upstream.
The error path while failing to register devices on the TEE bus has a bug leading to kernel panic as follows:
[ 15.398930] Unable to handle kernel paging request at virtual address ffff07ed00626d7c [ 15.406913] Mem abort info: [ 15.409722] ESR = 0x0000000096000005 [ 15.413490] EC = 0x25: DABT (current EL), IL = 32 bits [ 15.418814] SET = 0, FnV = 0 [ 15.421878] EA = 0, S1PTW = 0 [ 15.425031] FSC = 0x05: level 1 translation fault [ 15.429922] Data abort info: [ 15.432813] ISV = 0, ISS = 0x00000005, ISS2 = 0x00000000 [ 15.438310] CM = 0, WnR = 0, TnD = 0, TagAccess = 0 [ 15.443372] GCS = 0, Overlay = 0, DirtyBit = 0, Xs = 0 [ 15.448697] swapper pgtable: 4k pages, 48-bit VAs, pgdp=00000000d9e3e000 [ 15.455413] [ffff07ed00626d7c] pgd=1800000bffdf9003, p4d=1800000bffdf9003, pud=0000000000000000 [ 15.464146] Internal error: Oops: 0000000096000005 [#1] PREEMPT SMP
Commit 7269cba53d90 ("tee: optee: Fix supplicant based device enumeration") lead to the introduction of this bug. So fix it appropriately.
--- drivers/tee/optee/device.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/tee/optee/device.c +2 -1
@@ -90,13 +90,14 @@ static int optee_register_device(const uif (rc) {pr_err ("device registration failed, err: %d\n" , rc);put_device (&optee_device->dev); +return rc; }if (func ==PTA_CMD_GET_DEVICES_SUPP )device_create_file (&optee_device->dev, &dev_attr_need_supplicant); -return rc; +return 0 ; }static int __optee_enumerate_devices (u32 func)
Greg Kroah-Hartman
maintainerPATCH 136/690 i2c: i801: Avoid potential double call to gpiod_remove_lookup_table
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Heiner Kallweit <[email protected]>
commit ceb013b2d9a2946035de5e1827624edc85ae9484 upstream.
If registering the platform device fails, the lookup table is removed in the error path. On module removal we would try to remove the lookup table again. Fix this by setting priv->lookup only if registering the platform device was successful. In addition free the memory allocated for the lookup table in the error path.
--- drivers/i2c/busses/i2c-i801.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/i2c/busses/i2c-i801.c +3 -1
@@ -1416,7 +1416,6 @@ static int i801_add_mux(struct i801_priv mux_config->gpios[i], "mux", 0); }gpiod_add_lookup_table (lookup); - priv->lookup = lookup;/* * Register the mux device, we use PLATFORM_DEVID_NONE here
@@ -1430,7 +1429,10 @@ static int i801_add_mux(struct i801_priv sizeof(struct i2c_mux_gpio_platform_data));if (IS_ERR (priv->mux_pdev)) {gpiod_remove_lookup_table (lookup); +devm_kfree (dev, lookup);dev_err (dev,"Failed to register i2c-mux-gpio device\n" ); + }else { + priv->lookup = lookup; }return PTR_ERR_OR_ZERO (priv->mux_pdev);
Greg Kroah-Hartman
maintainerPATCH 137/690 xen/events: close evtchn after mapping cleanup
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Maximilian Heyne <[email protected]>
commit fa765c4b4aed2d64266b694520ecb025c862c5a9 upstream.
shutdown_pirq and startup_pirq are not taking the irq_mapping_update_lock because they can't due to lock inversion. Both are called with the irq_desc->lock being taking. The lock order, however, is first irq_mapping_update_lock and then irq_desc->lock.
This opens multiple races:
- shutdown_pirq can be interrupted by a function that allocates an event channel:
CPU0 CPU1
shutdown_pirq {
xen_evtchn_close(e)
__startup_pirq {
EVTCHNOP_bind_pirq
-> returns just freed evtchn e
set_evtchn_to_irq(e, irq)
}
xen_irq_info_cleanup() {
set_evtchn_to_irq(e, -1)
}
} Assume here event channel e refers here to the same event channel number.
After this race the evtchn_to_irq mapping for e is invalid (-1).
- __startup_pirq races with __unbind_from_irq in a similar way. Because __startup_pirq doesn't take irq_mapping_update_lock it can grab the evtchn that __unbind_from_irq is currently freeing and cleaning up. In this case even though the event channel is allocated, its mapping can be unset in evtchn_to_irq.
The fix is to first cleanup the mappings and then close the event channel. In this way, when an event channel gets allocated it's potential previous evtchn_to_irq mappings are guaranteed to be unset already. This is also the reverse order of the allocation where first the event channel is allocated and then the mappings are setup.
On a 5.10 kernel prior to commit 3fcdaf3d7634 ("xen/events: modify internal [un]bind interfaces"), we hit a BUG like the following during probing of NVMe devices. The issue is that during nvme_setup_io_queues, pci_free_irq is called for every device which results in a call to shutdown_pirq. With many nvme devices it's therefore likely to hit this race during boot because there will be multiple calls to shutdown_pirq and startup_pirq are running potentially in parallel.
------------[ cut here ]------------ blkfront: xvda: barrier or flush: disabled; persistent grants: enabled; indirect descriptors: enabled; bounce buffer: enabled kernel BUG at drivers/xen/events/events_base.c:499! invalid opcode: 0000 [#1] SMP PTI CPU: 44 PID: 375 Comm: kworker/u257:23 Not tainted 5.10.201-191.748.amzn2.x86_64 #1 Hardware name: Xen HVM domU, BIOS 4.11.amazon 08/24/2006 Workqueue: nvme-reset-wq nvme_reset_work RIP: 0010:bind_evtchn_to_cpu+0xdf/0xf0 Code: 5d 41 5e c3 cc cc cc cc 44 89 f7 e8 2b 55 ad ff 49 89 c5 48 85 c0 0f 84 64 ff ff ff 4c 8b 68 30 41 83 fe ff 0f 85 60 ff ff ff <0f> 0b 66 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 40 00 0f 1f 44 00 00 RSP: 0000:ffffc9000d533b08 EFLAGS: 00010046 RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000006 RDX: 0000000000000028 RSI: 00000000ffffffff RDI: 00000000ffffffff RBP: ffff888107419680 R08: 0000000000000000 R09: ffffffff82d72b00 R10: 0000000000000000 R11: 0000000000000000 R12: 00000000000001ed R13: 0000000000000000 R14: 00000000ffffffff R15: 0000000000000002 FS: 0000000000000000(0000) GS:ffff88bc8b500000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 0000000000000000 CR3: 0000000002610001 CR4: 00000000001706e0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: ? show_trace_log_lvl+0x1c1/0x2d9 ? show_trace_log_lvl+0x1c1/0x2d9 ? set_affinity_irq+0xdc/0x1c0 ? __die_body.cold+0x8/0xd ? die+0x2b/0x50 ? do_trap+0x90/0x110 ? bind_evtchn_to_cpu+0xdf/0xf0 ? do_error_trap+0x65/0x80 ? bind_evtchn_to_cpu+0xdf/0xf0 ? exc_invalid_op+0x4e/0x70 ? bind_evtchn_to_cpu+0xdf/0xf0 ? asm_exc_invalid_op+0x12/0x20 ? bind_evtchn_to_cpu+0xdf/0xf0 ? bind_evtchn_to_cpu+0xc5/0xf0 set_affinity_irq+0xdc/0x1c0 irq_do_set_affinity+0x1d7/0x1f0 irq_setup_affinity+0xd6/0x1a0 irq_startup+0x8a/0xf0 __setup_irq+0x639/0x6d0 ? nvme_suspend+0x150/0x150 request_threaded_irq+0x10c/0x180 ? nvme_suspend+0x150/0x150 pci_request_irq+0xa8/0xf0 ? __blk_mq_free_request+0x74/0xa0 queue_request_irq+0x6f/0x80 nvme_create_queue+0x1af/0x200 nvme_create_io_queues+0xbd/0xf0 nvme_setup_io_queues+0x246/0x320 ? nvme_irq_check+0x30/0x30 nvme_reset_work+0x1c8/0x400 process_one_work+0x1b0/0x350 worker_thread+0x49/0x310 ? process_one_work+0x350/0x350 kthread+0x11b/0x140 ? __kthread_bind_mask+0x60/0x60 ret_from_fork+0x22/0x30 Modules linked in: ---[ end trace a11715de1eee1873 ]---
--- drivers/xen/events/events_base.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/xen/events/events_base.c +2 -3
@@ -936,8 +936,8 @@ static void shutdown_pirq(struct irq_datreturn ;do_mask (info,EVT_MASK_REASON_EXPLICIT ); -xen_evtchn_close (evtchn);xen_irq_info_cleanup (info); +xen_evtchn_close (evtchn); }static void enable_pirq (struct irq_data *data)
@@ -981,8 +981,6 @@ static void __unbind_from_irq(unsigned iunsigned int cpu =cpu_from_irq (irq);struct xenbus_device *dev; -xen_evtchn_close (evtchn); -switch (type_from_irq (irq)) {case IRQT_VIRQ :per_cpu (virq_to_irq, cpu)[virq_from_irq (irq)] =-1 ;
@@ -1000,6 +998,7 @@ static void __unbind_from_irq(unsigned i }xen_irq_info_cleanup (info); +xen_evtchn_close (evtchn); }xen_free_irq (irq);
Greg Kroah-Hartman
maintainerPATCH 138/690 ACPI: CPPC: Use access_width over bit_width for system memory accesses
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jarred White <[email protected]>
commit 2f4a4d63a193be6fd530d180bb13c3592052904c upstream.
To align with ACPI 6.3+, since bit_width can be any 8-bit value, it cannot be depended on to be always on a clean 8b boundary. This was uncovered on the Cobalt 100 platform.
SError Interrupt on CPU26, code 0xbe000011 -- SError
CPU: 26 PID: 1510 Comm: systemd-udevd Not tainted 5.15.2.1-13 #1 Hardware name: MICROSOFT CORPORATION, BIOS MICROSOFT CORPORATION pstate: 62400009 (nZCv daif +PAN -UAO +TCO -DIT -SSBS BTYPE=--) pc : cppc_get_perf_caps+0xec/0x410 lr : cppc_get_perf_caps+0xe8/0x410 sp : ffff8000155ab730 x29: ffff8000155ab730 x28: ffff0080139d0038 x27: ffff0080139d0078 x26: 0000000000000000 x25: ffff0080139d0058 x24: 00000000ffffffff x23: ffff0080139d0298 x22: ffff0080139d0278 x21: 0000000000000000 x20: ffff00802b251910 x19: ffff0080139d0000 x18: ffffffffffffffff x17: 0000000000000000 x16: ffffdc7e111bad04 x15: ffff00802b251008 x14: ffffffffffffffff x13: ffff013f1fd63300 x12: 0000000000000006 x11: ffffdc7e128f4420 x10: 0000000000000000 x9 : ffffdc7e111badec x8 : ffff00802b251980 x7 : 0000000000000000 x6 : ffff0080139d0028 x5 : 0000000000000000 x4 : ffff0080139d0018 x3 : 00000000ffffffff x2 : 0000000000000008 x1 : ffff8000155ab7a0 x0 : 0000000000000000 Kernel panic - not syncing: Asynchronous SError Interrupt CPU: 26 PID: 1510 Comm: systemd-udevd Not tainted 5.15.2.1-13 #1 Hardware name: MICROSOFT CORPORATION, BIOS MICROSOFT CORPORATION Call trace: dump_backtrace+0x0/0x1e0 show_stack+0x24/0x30 dump_stack_lvl+0x8c/0xb8 dump_stack+0x18/0x34 panic+0x16c/0x384 add_taint+0x0/0xc0 arm64_serror_panic+0x7c/0x90 arm64_is_fatal_ras_serror+0x34/0xa4 do_serror+0x50/0x6c el1h_64_error_handler+0x40/0x74 el1h_64_error+0x7c/0x80 cppc_get_perf_caps+0xec/0x410 cppc_cpufreq_cpu_init+0x74/0x400 [cppc_cpufreq] cpufreq_online+0x2dc/0xa30 cpufreq_add_dev+0xc0/0xd4 subsys_interface_register+0x134/0x14c cpufreq_register_driver+0x1b0/0x354 cppc_cpufreq_init+0x1a8/0x1000 [cppc_cpufreq] do_one_initcall+0x50/0x250 do_init_module+0x60/0x27c load_module+0x2300/0x2570 __do_sys_finit_module+0xa8/0x114 __arm64_sys_finit_module+0x2c/0x3c invoke_syscall+0x78/0x100 el0_svc_common.constprop.0+0x180/0x1a0 do_el0_svc+0x84/0xa0 el0_svc+0x2c/0xc0 el0t_64_sync_handler+0xa4/0x12c el0t_64_sync+0x1a4/0x1a8
Instead, use access_width to determine the size and use the offset and width to shift and mask the bits to read/write out. Make sure to add a check for system memory since pcc redefines the access_width to subspace id.
If access_width is not set, then fall back to using bit_width.
[ eahariha: Backport to v5.15 by dropping SystemIO bits as
commit a2c8f92bea5f is not present ]
--- drivers/acpi/cppc_acpi.c | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-)
drivers/acpi/cppc_acpi.c +24 -3
@@ -161,6 +161,13 @@ show_cppc_data(cppc_get_perf_caps, cppc_show_cppc_data (cppc_get_perf_ctrs, cppc_perf_fb_ctrs, reference_perf);show_cppc_data (cppc_get_perf_ctrs, cppc_perf_fb_ctrs, wraparound_time); +/* Check for valid access_width, otherwise, fallback to using bit_width */ +#define GET_BIT_WIDTH (reg) ((reg)->access_width ? (8 << ((reg)->access_width - 1)) : (reg)->bit_width) + +/* Shift and apply the mask for CPC reads/writes */ +#define MASK_VAL (reg, val) ((val) >> ((reg)->bit_offset & \ + GENMASK(((reg)->bit_width), 0))) +static ssize_t show_feedback_ctrs (struct kobject *kobj,struct kobj_attribute *attr,char *buf) {
@@ -762,8 +769,10 @@ int acpi_cppc_processor_probe(struct acp }else if (gas_t->space_id ==ACPI_ADR_SPACE_SYSTEM_MEMORY ) {if (gas_t->address) {void __iomem *addr; +size_t access_width; - addr =ioremap (gas_t->address, gas_t->bit_width/8 ); + access_width =GET_BIT_WIDTH (gas_t) /8 ; + addr =ioremap (gas_t->address, access_width);if (!addr) goto out_free; cpc_ptr->cpc_regs[i-2 ].sys_mem_vaddr = addr;
@@ -936,6 +945,7 @@ static int cpc_read(int cpu, struct cpc_ {int ret_val =0 ;void __iomem *vaddr =NULL ; +int size;int pcc_ss_id =per_cpu (cpu_pcc_subspace_idx, cpu);struct cpc_reg *reg = ®_res->cpc_entry.reg;
@@ -955,7 +965,9 @@ static int cpc_read(int cpu, struct cpc_return acpi_os_read_memory ((acpi_physical_address )reg->address, val, reg->bit_width); -switch (reg->bit_width) { + size =GET_BIT_WIDTH (reg); + +switch (size) {case 8 : *val =readb_relaxed (vaddr);break ;
@@ -974,12 +986,16 @@ static int cpc_read(int cpu, struct cpc_ ret_val = -EFAULT ; } +if (reg->space_id ==ACPI_ADR_SPACE_SYSTEM_MEMORY ) + *val =MASK_VAL (reg, *val); +return ret_val; }static int cpc_write (int cpu,struct cpc_register_resource *reg_res,u64 val) {int ret_val =0 ; +int size;void __iomem *vaddr =NULL ;int pcc_ss_id =per_cpu (cpu_pcc_subspace_idx, cpu);struct cpc_reg *reg = ®_res->cpc_entry.reg;
@@ -994,7 +1010,12 @@ static int cpc_write(int cpu, struct cpcreturn acpi_os_write_memory ((acpi_physical_address )reg->address, val, reg->bit_width); -switch (reg->bit_width) { + size =GET_BIT_WIDTH (reg); + +if (reg->space_id ==ACPI_ADR_SPACE_SYSTEM_MEMORY ) + val =MASK_VAL (reg, val); + +switch (size) {case 8 :writeb_relaxed (val, vaddr);break ;
Greg Kroah-Hartman
maintainerPATCH 139/690 clocksource/drivers/arm_global_timer: Fix maximum prescaler value
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Martin Blumenstingl <[email protected]>
[ Upstream commit b34b9547cee41575a4fddf390f615570759dc999 ]
The prescaler in the "Global Timer Control Register bit assignments" is documented to use bits [15:8], which means that the maximum prescaler register value is 0xff.
--- drivers/clocksource/arm_global_timer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/clocksource/arm_global_timer.c +1 -1
@@ -32,7 +32,7 @@#define GT_CONTROL_IRQ_ENABLE BIT(2)/* banked */ #define GT_CONTROL_AUTO_INC BIT(3)/* banked */ #define GT_CONTROL_PRESCALER_SHIFT 8 -#define GT_CONTROL_PRESCALER_MAX 0xF +#define GT_CONTROL_PRESCALER_MAX 0xFF#define GT_CONTROL_PRESCALER_MASK (GT_CONTROL_PRESCALER_MAX << \ GT_CONTROL_PRESCALER_SHIFT)
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 140/690 entry: Respect changes to system call number by trace_sys_enter()
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: André Rösti <[email protected]>
[ Upstream commit fb13b11d53875e28e7fbf0c26b288e4ea676aa9f ]
When a probe is registered at the trace_sys_enter() tracepoint, and that probe changes the system call number, the old system call still gets executed. This worked correctly until commit b6ec41346103 ("core/entry:
Report syscall correctly for trace and audit"), which removed the re-evaluation of the syscall number after the trace point.
Restore the original semantics by re-evaluating the system call number after trace_sys_enter().
The performance impact of this re-evaluation is minimal because it only takes place when a trace point is active, and compared to the actual trace point overhead the read from a cache hot variable is negligible.
--- kernel/entry/common.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
kernel/entry/common.c +7 -1
@@ -73,8 +73,14 @@ static long syscall_trace_enter(struct pt_regs *regs, long syscall,/* Either of the above might have changed the syscall number */ syscall =syscall_get_nr (current, regs); -if (unlikely (work &SYSCALL_WORK_SYSCALL_TRACEPOINT )) +if (unlikely (work &SYSCALL_WORK_SYSCALL_TRACEPOINT )) {trace_sys_enter (regs, syscall); +/* +* Probes or BPF hooks in the tracepoint may have changed the +* system call number as well. +*/ + syscall =syscall_get_nr (current, regs); + }syscall_enter_audit (regs, syscall);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 141/690 minmax: add umin(a, b) and umax(a, b)
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Laight <[email protected]>
[ Upstream commit 80fcac55385ccb710d33a20dc1caaef29bd5a921 ]
Patch series "minmax: Relax type checks in min() and max()", v4.
The min() (etc) functions in minmax.h require that the arguments have exactly the same types.
However when the type check fails, rather than look at the types and fix the type of a variable/constant, everyone seems to jump on min_t(). In reality min_t() ought to be rare - when something unusual is being done, not normality.
The orginal min() (added in 2.4.9) replaced several inline functions and included the type - so matched the implicit casting of the function call. This was renamed min_t() in 2.4.10 and the current min() added. There is no actual indication that the conversion of negatve values to large unsigned values has ever been an actual problem.
A quick grep shows 5734 min() and 4597 min_t(). Having the casts on almost half of the calls shows that something is clearly wrong.
If the wrong type is picked (and it is far too easy to pick the type of the result instead of the larger input) then significant bits can get discarded.
Pretty much the worst example is in the derived clamp_val(), consider:
unsigned char x = 200u;
y = clamp_val(x, 10u, 300u);I also suspect that many of the min_t(u16, ...) are actually wrong. For example copy_data() in printk_ringbuffer.c contains:
data_size = min_t(u16, buf_size, len);
Here buf_size is 'unsigned int' and len 'u16', pass a 64k buffer (can you prove that doesn't happen?) and no data is returned. Apparantly it did - and has since been fixed.
The only reason that most of the min_t() are 'fine' is that pretty much all the values in the kernel are between 0 and INT_MAX.
Patch 1 adds umin(), this uses integer promotions to convert both arguments to 'unsigned long long'. It can be used to compare a signed type that is known to contain a non-negative value with an unsigned type. The compiler typically optimises it all away. Added first so that it can be referred to in patch 2.
Patch 2 replaces the 'same type' check with a 'same signedness' one. This makes min(unsigned_int_var, sizeof()) be ok. The error message is also improved and will contain the expanded form of both arguments (useful for seeing how constants are defined).
Patch 3 just fixes some whitespace.
Patch 4 allows comparisons of 'unsigned char' and 'unsigned short' to signed types. The integer promotion rules convert them both to 'signed int' prior to the comparison so they can never cause a negative value be converted to a large positive one.
Patch 5 (rewritted for v4) allows comparisons of unsigned values against non-negative constant integer expressions. This makes min(unsigned_int_var, 4) be ok.
The only common case that is still errored is the comparison of signed values against unsigned constant integer expressions below __INT_MAX__. Typcally min(int_val, sizeof (foo)), the real fix for this is casting the
constant: min(int_var, (int)sizeof (foo)).
With all the patches applied pretty much all the min_t() could be replaced by min(), and most of the rest by umin(). However they all need careful inspection due to code like:
sz = min_t(unsigned char, sz - 1, LIM - 1) + 1;
which converts 0 to LIM.
This patch (of 6):
umin() and umax() can be used when min()/max() errors a signed v unsigned compare when the signed value is known to be non-negative.
Unlike min_t(some_unsigned_type, a, b) umin() will never mask off high bits if an inappropriate type is selected.
The '+ 0u + 0ul + 0ull' may look strange.
The '+ 0u' is needed for 'signed int' on 64bit systems. The '+ 0ul' is needed for 'signed long' on 32bit systems. The '+ 0ull' is needed for 'signed long long'.
Stable-dep-of: 51b30ecb73b4 ("swiotlb: Fix alignment checks when both allocation and DMA masks are present")
--- include/linux/minmax.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
include/linux/minmax.h +17 -0
@@ -51,6 +51,23 @@*/ #define max (x, y) __careful_cmp(x, y, >) +/** +* umin - return minimum of two non-negative values +* Signed types are zero extended to match a larger unsigned type. +* @x: first value +* @y: second value +*/ +#define umin (x, y) \ + __careful_cmp((x) + 0u + 0ul + 0ull, (y) + 0u + 0ul + 0ull, <) + +/** +* umax - return maximum of two non-negative values +* @x: first value +* @y: second value +*/ +#define umax (x, y) \ + __careful_cmp((x) + 0u + 0ul + 0ull, (y) + 0u + 0ul + 0ull, >) +/** * min3 - return minimum of three values * @x: first value
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 142/690 swiotlb: Fix alignment checks when both allocation and DMA masks are present
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Will Deacon <[email protected]>
[ Upstream commit 51b30ecb73b481d5fac6ccf2ecb4a309c9ee3310 ]
Nicolin reports that swiotlb buffer allocations fail for an NVME device behind an IOMMU using 64KiB pages. This is because we end up with a minimum allocation alignment of 64KiB (for the IOMMU to map the buffer safely) but a minimum DMA alignment mask corresponding to a 4KiB NVME page (i.e. preserving the 4KiB page offset from the original allocation). If the original address is not 4KiB-aligned, the allocation will fail because swiotlb_search_pool_area() erroneously compares these unmasked bits with the 64KiB-aligned candidate allocation.
Tweak swiotlb_search_pool_area() so that the DMA alignment mask is reduced based on the required alignment of the allocation.
--- kernel/dma/swiotlb.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
kernel/dma/swiotlb.c +9 -2
@@ -469,8 +469,7 @@ static int swiotlb_find_slots(struct device *dev, phys_addr_t orig_addr,dma_addr_t tbl_dma_addr =phys_to_dma_unencrypted (dev, mem->start) & boundary_mask;unsigned long max_slots =get_max_slots (boundary_mask); -unsigned int iotlb_align_mask = -dma_get_min_align_mask (dev) & ~(IO_TLB_SIZE -1 ); +unsigned int iotlb_align_mask =dma_get_min_align_mask (dev);unsigned int nslots =nr_slots (alloc_size), stride;unsigned int index, wrap, count =0 , i;unsigned int offset =swiotlb_align_offset (dev, orig_addr);
@@ -478,6 +477,14 @@ static int swiotlb_find_slots(struct device *dev, phys_addr_t orig_addr,BUG_ON (!nslots); +/* +* Ensure that the allocation is at least slot-aligned and update +* 'iotlb_align_mask' to ignore bits that will be preserved when +* offsetting into the allocation. +*/ + alloc_align_mask |= (IO_TLB_SIZE -1 ); + iotlb_align_mask &= ~alloc_align_mask; +/* * For mappings with an alignment requirement don't bother looping to * unaligned slots once we found an aligned one. For allocations of
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 143/690 dma-mapping: add dma_opt_mapping_size()
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: John Garry <[email protected]>
[ Upstream commit a229cc14f3395311b899e5e582b71efa8dd01df0 ]
Streaming DMA mapping involving an IOMMU may be much slower for larger total mapping size. This is because every IOMMU DMA mapping requires an IOVA to be allocated and freed. IOVA sizes above a certain limit are not cached, which can have a big impact on DMA mapping performance.
Provide an API for device drivers to know this "optimal" limit, such that they may try to produce mapping which don't exceed it.
Stable-dep-of: afc5aa46ed56 ("iommu/dma: Force swiotlb_max_mapping_size on an untrusted device")
--- Documentation/core-api/dma-api.rst | 14 ++++++++++++++ include/linux/dma-map-ops.h | 1 + include/linux/dma-mapping.h | 5 +++++ kernel/dma/mapping.c | 12 ++++++++++++ 4 files changed, 32 insertions(+)
Documentation/core-api/dma-api.rst +14 -0
@@ -204,6 +204,20 @@ Returns the maximum size of a mapping for the device. The size parameter of the mapping functions like dma_map_single(), dma_map_page() and others should not be larger than the returned value. +:: + + size_t + dma_opt_mapping_size(struct device *dev); + +Returns the maximum optimal size of a mapping for the device. + +Mapping larger buffers may take much longer in certain scenarios. In +addition, for high-rate short-lived streaming mappings, the upfront time +spent on the mapping may account for an appreciable part of the total +request lifetime. As such, if splitting larger requests incurs no +significant performance penalty, then device drivers are advised to +limit total DMA streaming mappings length to the returned value. + :: bool
include/linux/dma-map-ops.h +1 -0
@@ -69,6 +69,7 @@ struct dma_map_ops {int (*dma_supported)(struct device *dev,u64 mask);u64 (*get_required_mask)(struct device *dev);size_t (*max_mapping_size)(struct device *dev); +size_t (*opt_mapping_size)(void );unsigned long (*get_merge_boundary)(struct device *dev); };
include/linux/dma-mapping.h +5 -0
@@ -144,6 +144,7 @@ int dma_set_mask(struct device *dev, u64 mask);int dma_set_coherent_mask (struct device *dev,u64 mask);u64 dma_get_required_mask (struct device *dev);size_t dma_max_mapping_size (struct device *dev); +size_t dma_opt_mapping_size (struct device *dev);bool dma_need_sync (struct device *dev,dma_addr_t dma_addr);unsigned long dma_get_merge_boundary (struct device *dev); struct sg_table *dma_alloc_noncontiguous(struct device *dev, size_t size,
@@ -266,6 +267,10 @@ static inline size_t dma_max_mapping_size(struct device *dev) {return 0 ; } +static inline size_t dma_opt_mapping_size (struct device *dev) +{ +return 0 ; +}static inline bool dma_need_sync (struct device *dev,dma_addr_t dma_addr) {return false;
kernel/dma/mapping.c +12 -0
@@ -777,6 +777,18 @@ size_t dma_max_mapping_size(struct device *dev) }EXPORT_SYMBOL_GPL (dma_max_mapping_size); +size_t dma_opt_mapping_size (struct device *dev) +{ +const struct dma_map_ops *ops =get_dma_ops (dev); +size_t size =SIZE_MAX ; + +if (ops && ops->opt_mapping_size) + size = ops->opt_mapping_size (); + +return min (dma_max_mapping_size (dev), size); +} +EXPORT_SYMBOL_GPL (dma_opt_mapping_size); +bool dma_need_sync (struct device *dev,dma_addr_t dma_addr) {const struct dma_map_ops *ops =get_dma_ops (dev);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 144/690 dma-iommu: add iommu_dma_opt_mapping_size()
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: John Garry <[email protected]>
[ Upstream commit 6d9870b7e5def2450e21316515b9efc0529204dd ]
Add the IOMMU callback for DMA mapping API dma_opt_mapping_size(), which allows the drivers to know the optimal mapping limit and thus limit the requested IOVA lengths.
This value is based on the IOVA rcache range limit, as IOVAs allocated above this limit must always be newly allocated, which may be quite slow.
Stable-dep-of: afc5aa46ed56 ("iommu/dma: Force swiotlb_max_mapping_size on an untrusted device")
--- drivers/iommu/dma-iommu.c | 6 ++++++ drivers/iommu/iova.c | 5 +++++ include/linux/iova.h | 2 ++ 3 files changed, 13 insertions(+)
drivers/iommu/dma-iommu.c +6 -0
@@ -1291,6 +1291,11 @@ static unsigned long iommu_dma_get_merge_boundary(struct device *dev)return (1UL <<__ffs (domain->pgsize_bitmap)) -1 ; } +static size_t iommu_dma_opt_mapping_size (void ) +{ +return iova_rcache_range (); +} +static const struct dma_map_ops iommu_dma_ops = { .alloc = iommu_dma_alloc, .free = iommu_dma_free,
@@ -1313,6 +1318,7 @@ static const struct dma_map_ops iommu_dma_ops = { .map_resource = iommu_dma_map_resource, .unmap_resource = iommu_dma_unmap_resource, .get_merge_boundary = iommu_dma_get_merge_boundary, + .opt_mapping_size = iommu_dma_opt_mapping_size, };/*
drivers/iommu/iova.c +5 -0
@@ -27,6 +27,11 @@ static void free_iova_rcaches(struct iova_domain *iovad);static void fq_destroy_all_entries (struct iova_domain *iovad);static void fq_flush_timeout (struct timer_list *t); +unsigned long iova_rcache_range (void ) +{ +return PAGE_SIZE << (IOVA_RANGE_CACHE_MAX_SIZE -1 ); +} +static int iova_cpuhp_dead (unsigned int cpu,struct hlist_node *node) {struct iova_domain *iovad;
include/linux/iova.h +2 -0
@@ -137,6 +137,8 @@ static inline unsigned long iova_pfn(struct iova_domain *iovad, dma_addr_t iova)int iova_cache_get (void );void iova_cache_put (void ); +unsigned long iova_rcache_range (void ); +void free_iova (struct iova_domain *iovad,unsigned long pfn);void __free_iova (struct iova_domain *iovad,struct iova *iova); struct iova *alloc_iova(struct iova_domain *iovad, unsigned long size,
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 145/690 iommu/dma: Force swiotlb_max_mapping_size on an untrusted device
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Nicolin Chen <[email protected]>
[ Upstream commit afc5aa46ed560f01ceda897c053c6a40c77ce5c4 ]
The swiotlb does not support a mapping size > swiotlb_max_mapping_size().
On the other hand, with a 64KB PAGE_SIZE configuration, it's observed that
an NVME device can map a size between 300KB~512KB, which certainly failed
the swiotlb mappings, though the default pool of swiotlb has many slots:
systemd[1]: Started Journal Service.
=> nvme 0000:00:01.0: swiotlb buffer is full (sz: 327680 bytes), total 32768 (slots), used 32 (slots)
note: journal-offline[392] exited with irqs disabled
note: journal-offline[392] exited with preempt_count 1
Call trace: [ 3.099918] swiotlb_tbl_map_single+0x214/0x240 [ 3.099921] iommu_dma_map_page+0x218/0x328 [ 3.099928] dma_map_page_attrs+0x2e8/0x3a0 [ 3.101985] nvme_prep_rq.part.0+0x408/0x878 [nvme] [ 3.102308] nvme_queue_rqs+0xc0/0x300 [nvme] [ 3.102313] blk_mq_flush_plug_list.part.0+0x57c/0x600 [ 3.102321] blk_add_rq_to_plug+0x180/0x2a0 [ 3.102323] blk_mq_submit_bio+0x4c8/0x6b8 [ 3.103463] __submit_bio+0x44/0x220 [ 3.103468] submit_bio_noacct_nocheck+0x2b8/0x360 [ 3.103470] submit_bio_noacct+0x180/0x6c8 [ 3.103471] submit_bio+0x34/0x130 [ 3.103473] ext4_bio_write_folio+0x5a4/0x8c8 [ 3.104766] mpage_submit_folio+0xa0/0x100 [ 3.104769] mpage_map_and_submit_buffers+0x1a4/0x400 [ 3.104771] ext4_do_writepages+0x6a0/0xd78 [ 3.105615] ext4_writepages+0x80/0x118 [ 3.105616] do_writepages+0x90/0x1e8 [ 3.105619] filemap_fdatawrite_wbc+0x94/0xe0 [ 3.105622] __filemap_fdatawrite_range+0x68/0xb8 [ 3.106656] file_write_and_wait_range+0x84/0x120 [ 3.106658] ext4_sync_file+0x7c/0x4c0 [ 3.106660] vfs_fsync_range+0x3c/0xa8 [ 3.106663] do_fsync+0x44/0xc0
Since untrusted devices might go down the swiotlb pathway with dma-iommu, these devices should not map a size larger than swiotlb_max_mapping_size.
To fix this bug, add iommu_dma_max_mapping_size() for untrusted devices to take into account swiotlb_max_mapping_size() v.s. iova_rcache_range() from the iommu_dma_opt_mapping_size().
--- drivers/iommu/dma-iommu.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/iommu/dma-iommu.c +9 -0
@@ -1296,6 +1296,14 @@ static size_t iommu_dma_opt_mapping_size(void)return iova_rcache_range (); } +static size_t iommu_dma_max_mapping_size (struct device *dev) +{ +if (dev_is_untrusted (dev)) +return swiotlb_max_mapping_size (dev); + +return SIZE_MAX ; +} +static const struct dma_map_ops iommu_dma_ops = { .alloc = iommu_dma_alloc, .free = iommu_dma_free,
@@ -1319,6 +1327,7 @@ static const struct dma_map_ops iommu_dma_ops = { .unmap_resource = iommu_dma_unmap_resource, .get_merge_boundary = iommu_dma_get_merge_boundary, .opt_mapping_size = iommu_dma_opt_mapping_size, + .max_mapping_size = iommu_dma_max_mapping_size, };/*
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 146/690 printk: Update @console_may_schedule in console_trylock_spinning()
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: John Ogness <[email protected]>
[ Upstream commit 8076972468584d4a21dab9aa50e388b3ea9ad8c7 ]
console_trylock_spinning() may takeover the console lock from a schedulable context. Update @console_may_schedule to make sure it reflects a trylock acquire.
--- kernel/printk/printk.c | 6 ++++++ 1 file changed, 6 insertions(+)
kernel/printk/printk.c +6 -0
@@ -1908,6 +1908,12 @@ static int console_trylock_spinning(void)*/ mutex_acquire (&console_lock_dep_map,0 ,1 , _THIS_IP_); +/* +* Update @console_may_schedule for trylock because the previous +* owner may have been schedulable. +*/ + console_may_schedule =0 ; +return 1 ; }
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 147/690 tty: serial: imx: Fix broken RS485
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Rickard x Andersson <[email protected]>
commit 672448ccf9b6a676f96f9352cbf91f4d35f4084a upstream.
When about to transmit the function imx_uart_start_tx is called and in some RS485 configurations this function will call imx_uart_stop_rx. The problem is that imx_uart_stop_rx will enable loopback in order to release the RS485 bus, but when loopback is enabled transmitted data will just be looped to RX.
This patch fixes the above problem by not enabling loopback when about to transmit.
This driver now works well when used for RS485 half duplex master configurations.
--- drivers/tty/serial/imx.c | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-)
drivers/tty/serial/imx.c +18 -4
@@ -491,8 +491,7 @@ static void imx_uart_stop_tx(struct uart } } -/* called with port.lock taken and irqs off */ -static void imx_uart_stop_rx (struct uart_port *port) +static void imx_uart_stop_rx_with_loopback_ctrl (struct uart_port *port,bool loopback) {struct imx_port *sport = (struct imx_port *)port;u32 ucr1, ucr2, ucr4, uts;
@@ -514,7 +513,7 @@ static void imx_uart_stop_rx(struct uart/* See SER_RS485_ENABLED/UTS_LOOP comment in imx_uart_probe() */ if (port->rs485.flags &SER_RS485_ENABLED && port->rs485.flags &SER_RS485_RTS_ON_SEND && - sport->have_rtscts && !sport->have_rtsgpio) { + sport->have_rtscts && !sport->have_rtsgpio && loopback) { uts =imx_uart_readl (sport,imx_uart_uts_reg (sport)); uts |=UTS_LOOP ;imx_uart_writel (sport, uts,imx_uart_uts_reg (sport));
@@ -527,6 +526,16 @@ static void imx_uart_stop_rx(struct uart }/* called with port.lock taken and irqs off */ +static void imx_uart_stop_rx (struct uart_port *port) +{ +/* +* Stop RX and enable loopback in order to make sure RS485 bus +* is not blocked. Se comment in imx_uart_probe(). +*/ +imx_uart_stop_rx_with_loopback_ctrl (port, true); +} + +/* called with port.lock taken and irqs off */ static void imx_uart_enable_ms (struct uart_port *port) {struct imx_port *sport = (struct imx_port *)port;
@@ -714,8 +723,13 @@ static void imx_uart_start_tx(struct uarimx_uart_rts_inactive (sport, &ucr2);imx_uart_writel (sport, ucr2,UCR2 ); +/* +* Since we are about to transmit we can not stop RX +* with loopback enabled because that will make our +* transmitted data being just looped to RX. +*/ if (!(port->rs485.flags &SER_RS485_RX_DURING_TX )) -imx_uart_stop_rx (port); +imx_uart_stop_rx_with_loopback_ctrl (port, false); sport->tx_state =WAIT_AFTER_RTS ; start_hrtimer_ms(&sport->trigger_start_tx,
Greg Kroah-Hartman
maintainerPATCH 148/690 KVM: arm64: Work out supported block level at compile time
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Oliver Upton <[email protected]>
commit 3b5c082bbfa20d9a57924edd655bbe63fe98ab06 upstream.
Work out the minimum page table level where KVM supports block mappings at compile time. While at it, rewrite the comment around supported block mappings to directly describe what KVM supports instead of phrasing in terms of what it does not.
--- arch/arm64/include/asm/kvm_pgtable.h | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-)
arch/arm64/include/asm/kvm_pgtable.h +13 -5
@@ -13,6 +13,18 @@#define KVM_PGTABLE_MAX_LEVELS 4U +/* +* The largest supported block sizes for KVM (no 52-bit PA support): +* - 4K (level 1): 1GB +* - 16K (level 2): 32MB +* - 64K (level 2): 512MB +*/ +#ifdef CONFIG_ARM64_4K_PAGES +#define KVM_PGTABLE_MIN_BLOCK_LEVEL 1U +#else +#define KVM_PGTABLE_MIN_BLOCK_LEVEL 2U +#endif +static inline u64 kvm_get_parange (u64 mmfr0) { u64 parange = cpuid_feature_extract_unsigned_field(mmfr0,
@@ -58,11 +70,7 @@ static inline u64 kvm_granule_size(u32 lstatic inline bool kvm_level_supports_block_mapping (u32 level) { -/* -* Reject invalid block mappings and don't bother with 4TB mappings for -* 52-bit PAs. -*/ -return !(level ==0 || (PAGE_SIZE !=SZ_4K && level ==1 )); +return level >=KVM_PGTABLE_MIN_BLOCK_LEVEL ; }/**
Greg Kroah-Hartman
maintainerPATCH 149/690 KVM: arm64: Limit stage2_apply_range() batch size to largest block
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Oliver Upton <[email protected]>
commit 5994bc9e05c2f8811f233aa434e391cd2783f0f5 upstream.
Presently stage2_apply_range() works on a batch of memory addressed by a stage 2 root table entry for the VM. Depending on the IPA limit of the VM and PAGE_SIZE of the host, this could address a massive range of memory. Some examples:
4 level, 4K paging -> 512 GB batch size
3 level, 64K paging -> 4TB batch size
Unsurprisingly, working on such a large range of memory can lead to soft lockups. When running dirty_log_perf_test:
./dirty_log_perf_test -m -2 -s anonymous_thp -b 4G -v 48
watchdog: BUG: soft lockup - CPU#0 stuck for 45s! [dirty_log_perf_:16703] Modules linked in: vfat fat cdc_ether usbnet mii xhci_pci xhci_hcd sha3_generic gq(O) CPU: 0 PID: 16703 Comm: dirty_log_perf_ Tainted: G O 6.0.0-smp-DEV #1 pstate: 80400009 (Nzcv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--) pc : dcache_clean_inval_poc+0x24/0x38 lr : clean_dcache_guest_page+0x28/0x4c sp : ffff800021763990 pmr_save: 000000e0 x29: ffff800021763990 x28: 0000000000000005 x27: 0000000000000de0 x26: 0000000000000001 x25: 00400830b13bc77f x24: ffffad4f91ead9c0 x23: 0000000000000000 x22: ffff8000082ad9c8 x21: 0000fffafa7bc000 x20: ffffad4f9066ce50 x19: 0000000000000003 x18: ffffad4f92402000 x17: 000000000000011b x16: 000000000000011b x15: 0000000000000124 x14: ffff07ff8301d280 x13: 0000000000000000 x12: 00000000ffffffff x11: 0000000000010001 x10: fffffc0000000000 x9 : ffffad4f9069e580 x8 : 000000000000000c x7 : 0000000000000000 x6 : 000000000000003f x5 : ffff07ffa2076980 x4 : 0000000000000001 x3 : 000000000000003f x2 : 0000000000000040 x1 : ffff0830313bd000 x0 : ffff0830313bcc40 Call trace: dcache_clean_inval_poc+0x24/0x38 stage2_unmap_walker+0x138/0x1ec __kvm_pgtable_walk+0x130/0x1d4 __kvm_pgtable_walk+0x170/0x1d4 __kvm_pgtable_walk+0x170/0x1d4 __kvm_pgtable_walk+0x170/0x1d4 kvm_pgtable_stage2_unmap+0xc4/0xf8 kvm_arch_flush_shadow_memslot+0xa4/0x10c kvm_set_memslot+0xb8/0x454 __kvm_set_memory_region+0x194/0x244 kvm_vm_ioctl_set_memory_region+0x58/0x7c kvm_vm_ioctl+0x49c/0x560 __arm64_sys_ioctl+0x9c/0xd4 invoke_syscall+0x4c/0x124 el0_svc_common+0xc8/0x194 do_el0_svc+0x38/0xc0 el0_svc+0x2c/0xa4 el0t_64_sync_handler+0x84/0xf0 el0t_64_sync+0x1a0/0x1a4
Use the largest supported block mapping for the configured page size as the batch granularity. In so doing the walker is guaranteed to visit a leaf only once.
--- arch/arm64/include/asm/stage2_pgtable.h | 20 -------------------- arch/arm64/kvm/mmu.c | 9 ++++++++- 2 files changed, 8 insertions(+), 21 deletions(-)
arch/arm64/include/asm/stage2_pgtable.h +0 -20
@@ -11,13 +11,6 @@#include <linux/pgtable.h> /* -* PGDIR_SHIFT determines the size a top-level page table entry can map -* and depends on the number of levels in the page table. Compute the -* PGDIR_SHIFT for a given number of levels. -*/ -#define pt_levels_pgdir_shift (lvls) ARM64_HW_PGTABLE_LEVEL_SHIFT(4 - (lvls)) - -/* * The hardware supports concatenation of up to 16 tables at stage2 entry * level and we use the feature whenever possible, which means we resolve 4 * additional bits of address at the entry level.
@@ -30,11 +23,6 @@#define stage2_pgtable_levels (ipa) ARM64_HW_PGTABLE_LEVELS((ipa) - 4)#define kvm_stage2_levels (kvm) VTCR_EL2_LVLS(kvm->arch.vtcr) -/* stage2_pgdir_shift() is the size mapped by top-level stage2 entry for the VM */ -#define stage2_pgdir_shift (kvm) pt_levels_pgdir_shift(kvm_stage2_levels(kvm)) -#define stage2_pgdir_size (kvm) (1ULL << stage2_pgdir_shift(kvm)) -#define stage2_pgdir_mask (kvm) ~(stage2_pgdir_size(kvm) - 1) -/* * kvm_mmmu_cache_min_pages() is the number of pages required to install * a stage-2 translation. We pre-allocate the entry level page table at
@@ -42,12 +30,4 @@*/ #define kvm_mmu_cache_min_pages (kvm) (kvm_stage2_levels(kvm) - 1) -static inline phys_addr_t -stage2_pgd_addr_end (struct kvm *kvm,phys_addr_t addr,phys_addr_t end) -{ -phys_addr_t boundary = (addr +stage2_pgdir_size (kvm)) &stage2_pgdir_mask (kvm); - -return (boundary -1 < end -1 ) ? boundary : end; -} -#endif /* __ARM64_S2_PGTABLE_H_ */
arch/arm64/kvm/mmu.c +8 -1
@@ -31,6 +31,13 @@ static phys_addr_t hyp_idmap_vector;static unsigned long io_map_base; +static phys_addr_t stage2_range_addr_end (phys_addr_t addr,phys_addr_t end) +{ +phys_addr_t size =kvm_granule_size (KVM_PGTABLE_MIN_BLOCK_LEVEL ); +phys_addr_t boundary =ALIGN_DOWN (addr + size, size); + +return (boundary -1 < end -1 ) ? boundary : end; +}/* * Release kvm_mmu_lock periodically if the memory region is large. Otherwise,
@@ -52,7 +59,7 @@ static int stage2_apply_range(struct kvmif (!pgt)return -EINVAL ; - next =stage2_pgd_addr_end (kvm, addr, end); + next =stage2_range_addr_end (addr, end); ret =fn (pgt, addr, next - addr);if (ret)break ;
Greg Kroah-Hartman
maintainerPATCH 150/690 x86/asm: Add _ASM_RIP() macro for x86-64 (%rip) suffix
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: "H. Peter Anvin (Intel)" <[email protected]>
commit f87bc8dc7a7c438c70f97b4e51c76a183313272e upstream.
Add a macro _ASM_RIP() to add a (%rip) suffix on 64 bits only. This is useful for immediate memory references where one doesn't want gcc to possibly use a register indirection as it may in the case of an "m" constraint.
[ pawan: resolved merged conflict for __ASM_REGPFX ]
--- arch/x86/include/asm/asm.h | 5 +++++ 1 file changed, 5 insertions(+)
arch/x86/include/asm/asm.h +5 -0
@@ -6,11 +6,13 @@# define __ASM_FORM (x, ...) x,## __VA_ARGS__# define __ASM_FORM_RAW (x, ...) x,## __VA_ARGS__# define __ASM_FORM_COMMA (x, ...) x,## __VA_ARGS__, +# define __ASM_REGPFX %#else #include <linux/stringify.h> # define __ASM_FORM (x, ...) " " __stringify(x,##__VA_ARGS__) " "# define __ASM_FORM_RAW (x, ...) __stringify(x,##__VA_ARGS__)# define __ASM_FORM_COMMA (x, ...) " " __stringify(x,##__VA_ARGS__) "," +# define __ASM_REGPFX %%#endif #define _ASM_BYTES (x, ...) __ASM_FORM(.byte x,##__VA_ARGS__ ;)
@@ -49,6 +51,9 @@#define _ASM_SI __ASM_REG(si)#define _ASM_DI __ASM_REG(di) +/* Adds a (%rip) suffix on 64 bits only; for immediate memory references */ +#define _ASM_RIP (x) __ASM_SEL_RAW(x, x (__ASM_REGPFX rip)) +#ifndef __x86_64__/* 32 bit */
Greg Kroah-Hartman
maintainerPATCH 151/690 x86/bugs: Add asm helpers for executing VERW
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit baf8361e54550a48a7087b603313ad013cc13386 upstream.
MDS mitigation requires clearing the CPU buffers before returning to user. This needs to be done late in the exit-to-user path. Current location of VERW leaves a possibility of kernel data ending up in CPU buffers for memory accesses done after VERW such as:
1. Kernel data accessed by an NMI between VERW and return-to-user can remain in CPU buffers since NMI returning to kernel does not execute VERW to clear CPU buffers.
2. Alyssa reported that after VERW is executed, CONFIG_GCC_PLUGIN_STACKLEAK=y scrubs the stack used by a system call. Memory accesses during stack scrubbing can move kernel stack contents into CPU buffers.
3. When caller saved registers are restored after a return from function executing VERW, the kernel stack accesses can remain in CPU buffers(since they occur after VERW).
To fix this VERW needs to be moved very late in exit-to-user path.
In preparation for moving VERW to entry/exit asm code, create macros that can be used in asm. Also make VERW patching depend on a new feature flag X86_FEATURE_CLEAR_CPU_BUF.
[pawan: - Runtime patch jmp instead of verw in macro CLEAR_CPU_BUFFERS
due to lack of relative addressing support for relocations in kernels < v6.5. - Add UNWIND_HINT_EMPTY to avoid warning: arch/x86/entry/entry.o: warning: objtool: mds_verw_sel+0x0: unreachable instruction]
--- arch/x86/entry/entry.S | 23 +++++++++++++++++++++++ arch/x86/include/asm/cpufeatures.h | 2 +- arch/x86/include/asm/nospec-branch.h | 15 +++++++++++++++ 3 files changed, 39 insertions(+), 1 deletion(-)
arch/x86/entry/entry.S +23 -0
@@ -6,6 +6,9 @@ #include <linux/linkage.h> #include <asm/export.h> #include <asm/msr-index.h> +#include <asm/unwind_hints.h> +#include <asm/segment.h> +#include <asm/cache.h> .pushsection .noinstr.text, "ax"
@@ -20,3 +23,23 @@ SYM_FUNC_END(entry_ibpb) EXPORT_SYMBOL_GPL(entry_ibpb); .popsection + +/* + * Define the VERW operand that is disguised as entry code so that + * it can be referenced with KPTI enabled. This ensure VERW can be + * used late in exit-to-user path after page tables are switched. + */ +.pushsection .entry.text, "ax" + +.align L1_CACHE_BYTES, 0xcc +SYM_CODE_START_NOALIGN(mds_verw_sel) + UNWIND_HINT_EMPTY + ANNOTATE_NOENDBR + .word __KERNEL_DS +.align L1_CACHE_BYTES, 0xcc +SYM_CODE_END(mds_verw_sel); +/* For KVM */ +EXPORT_SYMBOL_GPL(mds_verw_sel); + +.popsection +
arch/x86/include/asm/cpufeatures.h +1 -1
@@ -302,7 +302,7 @@#define X86_FEATURE_UNRET (11*32+15)/* "" AMD BTB untrain return */ #define X86_FEATURE_USE_IBPB_FW (11*32+16)/* "" Use IBPB during runtime firmware calls */ #define X86_FEATURE_RSB_VMEXIT_LITE (11*32+17)/* "" Fill RSB on VM exit when EIBRS is enabled */ - +#define X86_FEATURE_CLEAR_CPU_BUF (11*32+18)/* "" Clear CPU buffers using VERW */ #define X86_FEATURE_MSR_TSX_CTRL (11*32+20)/* "" MSR IA32_TSX_CTRL (Intel) implemented */
arch/x86/include/asm/nospec-branch.h +15 -0
@@ -182,6 +182,19 @@#endif .endm +/* + * Macro to execute VERW instruction that mitigate transient data sampling + * attacks such as MDS. On affected systems a microcode update overloaded VERW + * instruction to also clear the CPU buffers. VERW clobbers CFLAGS.ZF. + * + * Note: Only the memory operand variant of VERW clears the CPU buffers. + */ +.macro CLEAR_CPU_BUFFERS + ALTERNATIVE "jmp .Lskip_verw_\@", "", X86_FEATURE_CLEAR_CPU_BUF + verw _ASM_RIP(mds_verw_sel) +.Lskip_verw_\@: +.endm + #else /* __ASSEMBLY__ */#define ANNOTATE_RETPOLINE_SAFE \
@@ -364,6 +377,8 @@ DECLARE_STATIC_KEY_FALSE(switch_mm_cond_DECLARE_STATIC_KEY_FALSE (mmio_stale_data_clear); +extern u16 mds_verw_sel; +#include <asm/segment.h> /**
Greg Kroah-Hartman
maintainerPATCH 152/690 x86/entry_64: Add VERW just before userspace transition
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit 3c7501722e6b31a6e56edd23cea5e77dbb9ffd1a upstream.
Mitigation for MDS is to use VERW instruction to clear any secrets in CPU Buffers. Any memory accesses after VERW execution can still remain in CPU buffers. It is safer to execute VERW late in return to user path to minimize the window in which kernel data can end up in CPU buffers. There are not many kernel secrets to be had after SWITCH_TO_USER_CR3.
Add support for deploying VERW mitigation after user register state is restored. This helps minimize the chances of kernel data ending up into CPU buffers after executing VERW.
Note that the mitigation at the new location is not yet enabled.
Corner case not handled
=======================
Interrupts returning to kernel don't clear CPUs buffers since the exit-to-user path is expected to do that anyways. But, there could be a case when an NMI is generated in kernel after the exit-to-user path has cleared the buffers. This case is not handled and NMI returning to kernel don't clear CPU buffers because:
1. It is rare to get an NMI after VERW, but before returning to user.
2. For an unprivileged user, there is no known way to make that NMI less rare or target it.
3. It would take a large number of these precisely-timed NMIs to mount an actual attack. There's presumably not enough bandwidth.
4. The NMI in question occurs after a VERW, i.e. when user state is restored and most interesting data is already scrubbed. Whats left is only the data that NMI touches, and that may or may not be of any interest.
[ pawan: resolved conflict for hunk swapgs_restore_regs_and_return_to_usermode ]
--- arch/x86/entry/entry_64.S | 11 +++++++++++ arch/x86/entry/entry_64_compat.S | 1 + 2 files changed, 12 insertions(+)
arch/x86/entry/entry_64.S +11 -0
@@ -219,6 +219,7 @@ syscall_return_via_sysret: popq %rdi popq %rsp swapgs + CLEAR_CPU_BUFFERS sysretq SYM_CODE_END(entry_SYSCALL_64)
@@ -637,6 +638,7 @@ SYM_INNER_LABEL(swapgs_restore_regs_and_ /* Restore RDI. */ popq %rdi SWAPGS + CLEAR_CPU_BUFFERS INTERRUPT_RETURN
@@ -743,6 +745,8 @@ native_irq_return_ldt: */ popq %rax /* Restore user RAX */ + CLEAR_CPU_BUFFERS + /* * RSP now points to an ordinary IRET frame, except that the page * is read-only and RSP[31:16] are preloaded with the userspace
@@ -1466,6 +1470,12 @@ nmi_restore: movq $0, 5*8(%rsp) /* clear "NMI executing" */ /* + * Skip CLEAR_CPU_BUFFERS here, since it only helps in rare cases like + * NMI in kernel after user state is restored. For an unprivileged user + * these conditions are hard to meet. + */ + + /* * iretq reads the "iret" frame and exits the NMI stack in a * single instruction. We are returning to kernel mode, so this * cannot result in a fault. Similarly, we don't need to worry
@@ -1482,6 +1492,7 @@ SYM_CODE_END(asm_exc_nmi) SYM_CODE_START(ignore_sysret) UNWIND_HINT_EMPTY mov $-ENOSYS, %eax + CLEAR_CPU_BUFFERS sysretl SYM_CODE_END(ignore_sysret) #endif
arch/x86/entry/entry_64_compat.S +1 -0
@@ -319,6 +319,7 @@ sysret32_from_system_call: xorl %r9d, %r9d xorl %r10d, %r10d swapgs + CLEAR_CPU_BUFFERS sysretl SYM_CODE_END(entry_SYSCALL_compat)
Greg Kroah-Hartman
maintainerPATCH 153/690 x86/entry_32: Add VERW just before userspace transition
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit a0e2dab44d22b913b4c228c8b52b2a104434b0b3 upstream.
As done for entry_64, add support for executing VERW late in exit to user path for 32-bit mode.
--- arch/x86/entry/entry_32.S | 3 +++ 1 file changed, 3 insertions(+)
arch/x86/entry/entry_32.S +3 -0
@@ -912,6 +912,7 @@ SYM_FUNC_START(entry_SYSENTER_32) BUG_IF_WRONG_CR3 no_user_check=1 popfl popl %eax + CLEAR_CPU_BUFFERS /* * Return back to the vDSO, which will pop ecx and edx.
@@ -981,6 +982,7 @@ restore_all_switch_stack: /* Restore user state */ RESTORE_REGS pop=4 # skip orig_eax/error_code + CLEAR_CPU_BUFFERS .Lirq_return: /* * ARCH_HAS_MEMBARRIER_SYNC_CORE rely on IRET core serialization
@@ -1173,6 +1175,7 @@ SYM_CODE_START(asm_exc_nmi) /* Not on SYSENTER stack. */ call exc_nmi + CLEAR_CPU_BUFFERS jmp .Lnmi_return .Lnmi_from_sysenter_stack:
Greg Kroah-Hartman
maintainerPATCH 154/690 x86/bugs: Use ALTERNATIVE() instead of mds_user_clear static key
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit 6613d82e617dd7eb8b0c40b2fe3acea655b1d611 upstream.
The VERW mitigation at exit-to-user is enabled via a static branch mds_user_clear. This static branch is never toggled after boot, and can be safely replaced with an ALTERNATIVE() which is convenient to use in asm.
Switch to ALTERNATIVE() to use the VERW mitigation late in exit-to-user path. Also remove the now redundant VERW in exc_nmi() and arch_exit_to_user_mode().
--- Documentation/x86/mds.rst | 36 +++++++++++++++++++++++++---------- arch/x86/include/asm/entry-common.h | 1 arch/x86/include/asm/nospec-branch.h | 12 ----------- arch/x86/kernel/cpu/bugs.c | 15 +++++--------- arch/x86/kernel/nmi.c | 3 -- arch/x86/kvm/vmx/vmx.c | 2 - 6 files changed, 33 insertions(+), 36 deletions(-)
Documentation/x86/mds.rst +26 -10
@@ -95,6 +95,9 @@ The kernel provides a function to invoke mds_clear_cpu_buffers() +Also macro CLEAR_CPU_BUFFERS can be used in ASM late in exit-to-user path. +Other than CFLAGS.ZF, this macro doesn't clobber any registers. + The mitigation is invoked on kernel/userspace, hypervisor/guest and C-state (idle) transitions.
@@ -138,17 +141,30 @@ Mitigation points When transitioning from kernel to user space the CPU buffers are flushed on affected CPUs when the mitigation is not disabled on the kernel - command line. The migitation is enabled through the static key - mds_user_clear. + command line. The mitigation is enabled through the feature flag + X86_FEATURE_CLEAR_CPU_BUF. - The mitigation is invoked in prepare_exit_to_usermode() which covers - all but one of the kernel to user space transitions. The exception - is when we return from a Non Maskable Interrupt (NMI), which is - handled directly in do_nmi(). - - (The reason that NMI is special is that prepare_exit_to_usermode() can - enable IRQs. In NMI context, NMIs are blocked, and we don't want to - enable IRQs with NMIs blocked.) + The mitigation is invoked just before transitioning to userspace after + user registers are restored. This is done to minimize the window in + which kernel data could be accessed after VERW e.g. via an NMI after + VERW. + + **Corner case not handled** + Interrupts returning to kernel don't clear CPUs buffers since the + exit-to-user path is expected to do that anyways. But, there could be + a case when an NMI is generated in kernel after the exit-to-user path + has cleared the buffers. This case is not handled and NMI returning to + kernel don't clear CPU buffers because: + + 1. It is rare to get an NMI after VERW, but before returning to userspace. + 2. For an unprivileged user, there is no known way to make that NMI + less rare or target it. + 3. It would take a large number of these precisely-timed NMIs to mount + an actual attack. There's presumably not enough bandwidth. + 4. The NMI in question occurs after a VERW, i.e. when user state is + restored and most interesting data is already scrubbed. Whats left + is only the data that NMI touches, and that may or may not be of + any interest. 2. C-State transition
arch/x86/include/asm/entry-common.h +0 -1
@@ -91,7 +91,6 @@ static inline void arch_exit_to_user_mod static __always_inline void arch_exit_to_user_mode(void) { -mds_user_clear_cpu_buffers ();amd_clear_divider (); }#define arch_exit_to_user_mode arch_exit_to_user_mode
arch/x86/include/asm/nospec-branch.h +0 -12
@@ -370,7 +370,6 @@ DECLARE_STATIC_KEY_FALSE(switch_to_cond_DECLARE_STATIC_KEY_FALSE (switch_mm_cond_ibpb);DECLARE_STATIC_KEY_FALSE (switch_mm_always_ibpb); -DECLARE_STATIC_KEY_FALSE (mds_user_clear);DECLARE_STATIC_KEY_FALSE (mds_idle_clear);DECLARE_STATIC_KEY_FALSE (switch_mm_cond_l1d_flush);
@@ -405,17 +404,6 @@ static __always_inline void mds_clear_cp }/** -* mds_user_clear_cpu_buffers - Mitigation for MDS and TAA vulnerability -* -* Clear CPU buffers if the corresponding static key is enabled -*/ -static __always_inline void mds_user_clear_cpu_buffers(void) -{ -if (static_branch_likely (&mds_user_clear)) -mds_clear_cpu_buffers (); -} - -/** * mds_idle_clear_cpu_buffers - Mitigation for MDS vulnerability * * Clear CPU buffers if the corresponding static key is enabled
arch/x86/kernel/cpu/bugs.c +6 -9
@@ -110,9 +110,6 @@ DEFINE_STATIC_KEY_FALSE(switch_mm_cond_i/* Control unconditional IBPB in switch_mm() */ DEFINE_STATIC_KEY_FALSE (switch_mm_always_ibpb); -/* Control MDS CPU buffer clear before returning to user space */ -DEFINE_STATIC_KEY_FALSE (mds_user_clear); -EXPORT_SYMBOL_GPL (mds_user_clear);/* Control MDS CPU buffer clear before idling (halt, mwait) */ DEFINE_STATIC_KEY_FALSE (mds_idle_clear);EXPORT_SYMBOL_GPL (mds_idle_clear);
@@ -258,7 +255,7 @@ static void __init mds_select_mitigationif (!boot_cpu_has (X86_FEATURE_MD_CLEAR )) mds_mitigation =MDS_MITIGATION_VMWERV ; -static_branch_enable (&mds_user_clear); +setup_force_cpu_cap (X86_FEATURE_CLEAR_CPU_BUF );if (!boot_cpu_has (X86_BUG_MSBDS_ONLY ) && (mds_nosmt ||cpu_mitigations_auto_nosmt ()))
@@ -362,7 +359,7 @@ static void __init taa_select_mitigation* For guests that can't determine whether the correct microcode is * present on host, enable the mitigation for UCODE_NEEDED as well. */ -static_branch_enable (&mds_user_clear); +setup_force_cpu_cap (X86_FEATURE_CLEAR_CPU_BUF );if (taa_nosmt ||cpu_mitigations_auto_nosmt ())cpu_smt_disable (false);
@@ -430,7 +427,7 @@ static void __init mmio_select_mitigatio*/ if (boot_cpu_has_bug (X86_BUG_MDS ) || (boot_cpu_has_bug (X86_BUG_TAA ) &&boot_cpu_has (X86_FEATURE_RTM ))) -static_branch_enable (&mds_user_clear); +setup_force_cpu_cap (X86_FEATURE_CLEAR_CPU_BUF );else static_branch_enable (&mmio_stale_data_clear);
@@ -490,12 +487,12 @@ static void __init md_clear_update_mitigif (cpu_mitigations_off ())return ; -if (!static_key_enabled (&mds_user_clear)) +if (!boot_cpu_has (X86_FEATURE_CLEAR_CPU_BUF )) goto out;/* -* mds_user_clear is now enabled. Update MDS, TAA and MMIO Stale Data -* mitigation, if necessary. +* X86_FEATURE_CLEAR_CPU_BUF is now enabled. Update MDS, TAA and MMIO +* Stale Data mitigation, if necessary. */ if (mds_mitigation ==MDS_MITIGATION_OFF &&boot_cpu_has_bug (X86_BUG_MDS )) {
arch/x86/kernel/nmi.c +0 -3
@@ -519,9 +519,6 @@ nmi_restart:write_cr2 (this_cpu_read (nmi_cr2));if (this_cpu_dec_return (nmi_state)) goto nmi_restart; - -if (user_mode (regs)) -mds_user_clear_cpu_buffers (); }#if defined(CONFIG_X86_64 ) &&IS_ENABLED (CONFIG_KVM_INTEL )
arch/x86/kvm/vmx/vmx.c +1 -1
@@ -6750,7 +6750,7 @@ static noinstr void vmx_vcpu_enter_exit(/* L1D Flush includes CPU buffer clear to mitigate MDS */ if (static_branch_unlikely (&vmx_l1d_should_flush))vmx_l1d_flush (vcpu); -else if (static_branch_unlikely (&mds_user_clear)) +else if (cpu_feature_enabled (X86_FEATURE_CLEAR_CPU_BUF ))mds_clear_cpu_buffers ();else if (static_branch_unlikely (&mmio_stale_data_clear) &&kvm_arch_has_assigned_device (vcpu->kvm))
Greg Kroah-Hartman
maintainerPATCH 155/690 KVM/VMX: Use BT+JNC, i.e. EFLAGS.CF to select VMRESUME vs. VMLAUNCH
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sean Christopherson <[email protected]>
commit 706a189dcf74d3b3f955e9384785e726ed6c7c80 upstream.
Use EFLAGS.CF instead of EFLAGS.ZF to track whether to use VMRESUME versus VMLAUNCH. Freeing up EFLAGS.ZF will allow doing VERW, which clobbers ZF, for MDS mitigations as late as possible without needing to duplicate VERW for both paths.
[ pawan: resolved merge conflict in __vmx_vcpu_run in backport. ]
--- arch/x86/kvm/vmx/run_flags.h | 7 +++++-- arch/x86/kvm/vmx/vmenter.S | 6 +++--- 2 files changed, 8 insertions(+), 5 deletions(-)
arch/x86/kvm/vmx/run_flags.h +5 -2
@@ -2,7 +2,10 @@#ifndef __KVM_X86_VMX_RUN_FLAGS_H#define __KVM_X86_VMX_RUN_FLAGS_H -#define VMX_RUN_VMRESUME (1 << 0) -#define VMX_RUN_SAVE_SPEC_CTRL (1 << 1) +#define VMX_RUN_VMRESUME_SHIFT 0 +#define VMX_RUN_SAVE_SPEC_CTRL_SHIFT 1 + +#define VMX_RUN_VMRESUME BIT(VMX_RUN_VMRESUME_SHIFT) +#define VMX_RUN_SAVE_SPEC_CTRL BIT(VMX_RUN_SAVE_SPEC_CTRL_SHIFT)#endif /* __KVM_X86_VMX_RUN_FLAGS_H */
arch/x86/kvm/vmx/vmenter.S +3 -3
@@ -77,7 +77,7 @@ SYM_FUNC_START(__vmx_vcpu_run) mov (%_ASM_SP), %_ASM_AX /* Check if vmlaunch or vmresume is needed */ - testb $VMX_RUN_VMRESUME, %bl + bt $VMX_RUN_VMRESUME_SHIFT, %bx /* Load guest registers. Don't clobber flags. */ mov VCPU_RCX(%_ASM_AX), %_ASM_CX
@@ -99,8 +99,8 @@ SYM_FUNC_START(__vmx_vcpu_run) /* Load guest RAX. This kills the @regs pointer! */ mov VCPU_RAX(%_ASM_AX), %_ASM_AX - /* Check EFLAGS.ZF from 'testb' above */ - jz .Lvmlaunch + /* Check EFLAGS.CF from the VMX_RUN_VMRESUME bit test above. */ + jnc .Lvmlaunch /* * After a successful VMRESUME/VMLAUNCH, control flow "magically"
Greg Kroah-Hartman
maintainerPATCH 156/690 KVM/VMX: Move VERW closer to VMentry for MDS mitigation
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit 43fb862de8f628c5db5e96831c915b9aebf62d33 upstream.
During VMentry VERW is executed to mitigate MDS. After VERW, any memory access like register push onto stack may put host data in MDS affected CPU buffers. A guest can then use MDS to sample host data.
Although likelihood of secrets surviving in registers at current VERW callsite is less, but it can't be ruled out. Harden the MDS mitigation by moving the VERW mitigation late in VMentry path.
Note that VERW for MMIO Stale Data mitigation is unchanged because of the complexity of per-guest conditional VERW which is not easy to handle that late in asm with no GPRs available. If the CPU is also affected by MDS, VERW is unconditionally executed late in asm regardless of guest having MMIO access.
[ pawan: conflict resolved in backport ]
--- arch/x86/kvm/vmx/vmenter.S | 3 +++ arch/x86/kvm/vmx/vmx.c | 12 ++++++++---- 2 files changed, 11 insertions(+), 4 deletions(-)
arch/x86/kvm/vmx/vmenter.S +3 -0
@@ -99,6 +99,9 @@ SYM_FUNC_START(__vmx_vcpu_run) /* Load guest RAX. This kills the @regs pointer! */ mov VCPU_RAX(%_ASM_AX), %_ASM_AX + /* Clobbers EFLAGS.ZF */ + CLEAR_CPU_BUFFERS + /* Check EFLAGS.CF from the VMX_RUN_VMRESUME bit test above. */ jnc .Lvmlaunch
arch/x86/kvm/vmx/vmx.c +8 -4
@@ -398,7 +398,8 @@ static __always_inline void vmx_enable_fstatic void vmx_update_fb_clear_dis (struct kvm_vcpu *vcpu,struct vcpu_vmx *vmx) { - vmx->disable_fb_clear = vmx_fb_clear_ctrl_available; + vmx->disable_fb_clear = !cpu_feature_enabled (X86_FEATURE_CLEAR_CPU_BUF ) && + vmx_fb_clear_ctrl_available;/* * If guest will not execute VERW, there is no need to set FB_CLEAR_DIS
@@ -6747,11 +6748,14 @@ static noinstr void vmx_vcpu_enter_exit( {kvm_guest_enter_irqoff (); -/* L1D Flush includes CPU buffer clear to mitigate MDS */ +/* +* L1D Flush includes CPU buffer clear to mitigate MDS, but VERW +* mitigation for MDS is done late in VMentry and is still +* executed in spite of L1D Flush. This is because an extra VERW +* should not matter much after the big hammer L1D Flush. +*/ if (static_branch_unlikely (&vmx_l1d_should_flush))vmx_l1d_flush (vcpu); -else if (cpu_feature_enabled (X86_FEATURE_CLEAR_CPU_BUF )) -mds_clear_cpu_buffers ();else if (static_branch_unlikely (&mmio_stale_data_clear) &&kvm_arch_has_assigned_device (vcpu->kvm))mds_clear_cpu_buffers ();
Greg Kroah-Hartman
maintainerPATCH 157/690 x86/mmio: Disable KVM mitigation when X86_FEATURE_CLEAR_CPU_BUF is set
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit e95df4ec0c0c9791941f112db699fae794b9862a upstream.
Currently MMIO Stale Data mitigation for CPUs not affected by MDS/TAA is to only deploy VERW at VMentry by enabling mmio_stale_data_clear static branch. No mitigation is needed for kernel->user transitions. If such CPUs are also affected by RFDS, its mitigation may set X86_FEATURE_CLEAR_CPU_BUF to deploy VERW at kernel->user and VMentry. This could result in duplicate VERW at VMentry.
Fix this by disabling mmio_stale_data_clear static branch when X86_FEATURE_CLEAR_CPU_BUF is enabled.
--- arch/x86/kernel/cpu/bugs.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
arch/x86/kernel/cpu/bugs.c +12 -2
@@ -428,6 +428,13 @@ static void __init mmio_select_mitigatioif (boot_cpu_has_bug (X86_BUG_MDS ) || (boot_cpu_has_bug (X86_BUG_TAA ) &&boot_cpu_has (X86_FEATURE_RTM )))setup_force_cpu_cap (X86_FEATURE_CLEAR_CPU_BUF ); + +/* +* X86_FEATURE_CLEAR_CPU_BUF could be enabled by other VERW based +* mitigations, disable KVM-only mitigation in that case. +*/ +if (boot_cpu_has (X86_FEATURE_CLEAR_CPU_BUF )) +static_branch_disable (&mmio_stale_data_clear);else static_branch_enable (&mmio_stale_data_clear);
@@ -504,8 +511,11 @@ static void __init md_clear_update_mitig taa_mitigation =TAA_MITIGATION_VERW ;taa_select_mitigation (); } -if (mmio_mitigation ==MMIO_MITIGATION_OFF && -boot_cpu_has_bug (X86_BUG_MMIO_STALE_DATA )) { +/* +* MMIO_MITIGATION_OFF is not checked here so that mmio_stale_data_clear +* gets updated correctly as per X86_FEATURE_CLEAR_CPU_BUF state. +*/ +if (boot_cpu_has_bug (X86_BUG_MMIO_STALE_DATA )) { mmio_mitigation =MMIO_MITIGATION_VERW ;mmio_select_mitigation (); }
Greg Kroah-Hartman
maintainerPATCH 158/690 Documentation/hw-vuln: Add documentation for RFDS
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit 4e42765d1be01111df0c0275bbaf1db1acef346e upstream.
Add the documentation for transient execution vulnerability Register File Data Sampling (RFDS) that affects Intel Atom CPUs.
[ pawan: s/ATOM_GRACEMONT/ALDERLAKE_N/ ]
--- Documentation/admin-guide/hw-vuln/index.rst | 1 Documentation/admin-guide/hw-vuln/reg-file-data-sampling.rst | 104 +++++++++++ 2 files changed, 105 insertions(+)
Documentation/admin-guide/hw-vuln/index.rst +1 -0
@@ -21,3 +21,4 @@ are configurable at compile, boot or run cross-thread-rsb.rst gather_data_sampling.rst srso + reg-file-data-sampling
Documentation/admin-guide/hw-vuln/reg-file-data-sampling.rst new file +104 -0
104 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 159/690 x86/rfds: Mitigate Register File Data Sampling (RFDS)
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit 8076fcde016c9c0e0660543e67bff86cb48a7c9c upstream.
RFDS is a CPU vulnerability that may allow userspace to infer kernel stale data previously used in floating point registers, vector registers and integer registers. RFDS only affects certain Intel Atom processors.
Intel released a microcode update that uses VERW instruction to clear the affected CPU buffers. Unlike MDS, none of the affected cores support SMT.
Add RFDS bug infrastructure and enable the VERW based mitigation by default, that clears the affected buffers just before exiting to userspace. Also add sysfs reporting and cmdline parameter "reg_file_data_sampling" to control the mitigation.
For details see:Documentation/admin-guide/hw-vuln/reg-file-data-sampling.rst
[ pawan: - Resolved conflicts in sysfs reporting.
- s/ATOM_GRACEMONT/ALDERLAKE_N/ATOM_GRACEMONT is called ALDERLAKE_N in 6.6. ]
--- Documentation/ABI/testing/sysfs-devices-system-cpu | 1 Documentation/admin-guide/kernel-parameters.txt | 21 +++++ arch/x86/Kconfig | 11 ++ arch/x86/include/asm/cpufeatures.h | 1 arch/x86/include/asm/msr-index.h | 8 ++ arch/x86/kernel/cpu/bugs.c | 78 ++++++++++++++++++++- arch/x86/kernel/cpu/common.c | 38 +++++++++- drivers/base/cpu.c | 8 ++ include/linux/cpu.h | 2 9 files changed, 162 insertions(+), 6 deletions(-)
Documentation/ABI/testing/sysfs-devices-system-cpu +1 -0
@@ -517,6 +517,7 @@ What: /sys/devices/system/cpu/vulnerabi /sys/devices/system/cpu/vulnerabilities/mds /sys/devices/system/cpu/vulnerabilities/meltdown /sys/devices/system/cpu/vulnerabilities/mmio_stale_data + /sys/devices/system/cpu/vulnerabilities/reg_file_data_sampling /sys/devices/system/cpu/vulnerabilities/retbleed /sys/devices/system/cpu/vulnerabilities/spec_store_bypass /sys/devices/system/cpu/vulnerabilities/spectre_v1
Documentation/admin-guide/kernel-parameters.txt +21 -0
@@ -1037,6 +1037,26 @@ The filter can be disabled or changed to another driver later using sysfs. + reg_file_data_sampling= + [X86] Controls mitigation for Register File Data + Sampling (RFDS) vulnerability. RFDS is a CPU + vulnerability which may allow userspace to infer + kernel data values previously stored in floating point + registers, vector registers, or integer registers. + RFDS only affects Intel Atom processors. + + on: Turns ON the mitigation. + off: Turns OFF the mitigation. + + This parameter overrides the compile time default set + by CONFIG_MITIGATION_RFDS. Mitigation cannot be + disabled when other VERW based mitigations (like MDS) + are enabled. In order to disable RFDS mitigation all + VERW based mitigations need to be disabled. + + For details see: + Documentation/admin-guide/hw-vuln/reg-file-data-sampling.rst + driver_async_probe= [KNL] List of driver names to be probed asynchronously. Format: <driver_name1>,<driver_name2>...
@@ -3070,6 +3090,7 @@ nopti [X86,PPC] nospectre_v1 [X86,PPC] nospectre_v2 [X86,PPC,S390,ARM64] + reg_file_data_sampling=off [X86] retbleed=off [X86] spec_store_bypass_disable=off [X86,PPC] spectre_v2_user=off [X86]
arch/x86/Kconfig +11 -0
@@ -2492,6 +2492,17 @@ config GDS_FORCE_MITIGATION If in doubt, say N. +config MITIGATION_RFDS + bool "RFDS Mitigation" + depends on CPU_SUP_INTEL + default y + help + Enable mitigation for Register File Data Sampling (RFDS) by default. + RFDS is a hardware vulnerability which affects Intel Atom CPUs. It + allows unprivileged speculative access to stale data previously + stored in floating point, vector and integer registers. + See also <file:Documentation/admin-guide/hw-vuln/reg-file-data-sampling.rst> + endif config ARCH_HAS_ADD_PAGES
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -467,4 +467,5 @@/* BUG word 2 */ #define X86_BUG_SRSO X86_BUG(1*32 + 0)/* AMD SRSO bug */ #define X86_BUG_DIV0 X86_BUG(1*32 + 1)/* AMD DIV0 speculation bug */ +#define X86_BUG_RFDS X86_BUG(1*32 + 2)/* CPU is vulnerable to Register File Data Sampling */ #endif /* _ASM_X86_CPUFEATURES_H */
arch/x86/include/asm/msr-index.h +8 -0
@@ -168,6 +168,14 @@* CPU is not vulnerable to Gather * Data Sampling (GDS). */ +#define ARCH_CAP_RFDS_NO BIT(27)/* +* Not susceptible to Register +* File Data Sampling. +*/ +#define ARCH_CAP_RFDS_CLEAR BIT(28)/* +* VERW clears CPU Register +* File. +*/ #define MSR_IA32_FLUSH_CMD 0x0000010b#define L1D_FLUSH BIT(0)/*
arch/x86/kernel/cpu/bugs.c +75 -3
120 lines not on this page · raw message
arch/x86/kernel/cpu/common.c +35 -3
@@ -1138,6 +1138,8 @@ static const __initconst struct x86_cpu_#define SRSO BIT(5)/* CPU is affected by GDS */ #define GDS BIT(6) +/* CPU is affected by Register File Data Sampling */ +#define RFDS BIT(7)static const struct x86_cpu_id cpu_vuln_blacklist[]__initconst = {VULNBL_INTEL_STEPPINGS (IVYBRIDGE ,X86_STEPPING_ANY ,SRBDS ),
@@ -1165,9 +1167,18 @@ static const struct x86_cpu_id cpu_vuln_VULNBL_INTEL_STEPPINGS (TIGERLAKE ,X86_STEPPING_ANY ,GDS ),VULNBL_INTEL_STEPPINGS (LAKEFIELD ,X86_STEPPING_ANY ,MMIO |MMIO_SBDS |RETBLEED ),VULNBL_INTEL_STEPPINGS (ROCKETLAKE ,X86_STEPPING_ANY ,MMIO |RETBLEED |GDS ), -VULNBL_INTEL_STEPPINGS (ATOM_TREMONT ,X86_STEPPING_ANY ,MMIO |MMIO_SBDS ), -VULNBL_INTEL_STEPPINGS (ATOM_TREMONT_D ,X86_STEPPING_ANY ,MMIO ), -VULNBL_INTEL_STEPPINGS (ATOM_TREMONT_L ,X86_STEPPING_ANY ,MMIO |MMIO_SBDS ), +VULNBL_INTEL_STEPPINGS (ALDERLAKE ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (ALDERLAKE_L ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (RAPTORLAKE ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (RAPTORLAKE_P ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (RAPTORLAKE_S ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (ALDERLAKE_N ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (ATOM_TREMONT ,X86_STEPPING_ANY ,MMIO |MMIO_SBDS |RFDS ), +VULNBL_INTEL_STEPPINGS (ATOM_TREMONT_D ,X86_STEPPING_ANY ,MMIO |RFDS ), +VULNBL_INTEL_STEPPINGS (ATOM_TREMONT_L ,X86_STEPPING_ANY ,MMIO |MMIO_SBDS |RFDS ), +VULNBL_INTEL_STEPPINGS (ATOM_GOLDMONT ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (ATOM_GOLDMONT_D ,X86_STEPPING_ANY ,RFDS ), +VULNBL_INTEL_STEPPINGS (ATOM_GOLDMONT_PLUS ,X86_STEPPING_ANY ,RFDS ),VULNBL_AMD (0x15 ,RETBLEED ), VULNBL_AMD(0x16, RETBLEED),
@@ -1201,6 +1212,24 @@ static bool arch_cap_mmio_immune(u64 ia3 ia32_cap & ARCH_CAP_SBDR_SSDP_NO); } +static bool __init vulnerable_to_rfds (u64 ia32_cap) +{ +/* The "immunity" bit trumps everything else: */ +if (ia32_cap &ARCH_CAP_RFDS_NO ) +return false; + +/* +* VMMs set ARCH_CAP_RFDS_CLEAR for processors not in the blacklist to +* indicate that mitigation is needed because guest is running on a +* vulnerable hardware or may migrate to such hardware: +*/ +if (ia32_cap &ARCH_CAP_RFDS_CLEAR ) +return true; + +/* Only consult the blacklist when there is no enumeration: */ +return cpu_matches (cpu_vuln_blacklist,RFDS ); +} +static void __init cpu_set_bug_bits (struct cpuinfo_x86 *c) {u64 ia32_cap =x86_read_arch_cap_msr ();
@@ -1312,6 +1341,9 @@ static void __init cpu_set_bug_bits(strusetup_force_cpu_bug (X86_BUG_SRSO ); } +if (vulnerable_to_rfds (ia32_cap)) +setup_force_cpu_bug (X86_BUG_RFDS ); +if (cpu_matches (cpu_vuln_whitelist,NO_MELTDOWN ))return ;
drivers/base/cpu.c +8 -0
@@ -589,6 +589,12 @@ ssize_t __weak cpu_show_spec_rstack_overreturn sysfs_emit (buf,"Not affected\n" ); } +ssize_t __weak cpu_show_reg_file_data_sampling (struct device *dev, +struct device_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"Not affected\n" ); +} + static DEVICE_ATTR(meltdown, 0444, cpu_show_meltdown, NULL); static DEVICE_ATTR(spectre_v1, 0444, cpu_show_spectre_v1, NULL); static DEVICE_ATTR(spectre_v2, 0444, cpu_show_spectre_v2, NULL);
@@ -602,6 +608,7 @@ static DEVICE_ATTR(mmio_stale_data, 0444 static DEVICE_ATTR(retbleed, 0444, cpu_show_retbleed, NULL); static DEVICE_ATTR(gather_data_sampling, 0444, cpu_show_gds, NULL); static DEVICE_ATTR(spec_rstack_overflow, 0444, cpu_show_spec_rstack_overflow, NULL); +static DEVICE_ATTR(reg_file_data_sampling, 0444, cpu_show_reg_file_data_sampling, NULL);static struct attribute *cpu_root_vulnerabilities_attrs[] = { &dev_attr_meltdown.attr,
@@ -617,6 +624,7 @@ static struct attribute *cpu_root_vulner &dev_attr_retbleed.attr, &dev_attr_gather_data_sampling.attr, &dev_attr_spec_rstack_overflow.attr, + &dev_attr_reg_file_data_sampling.attr, NULL };
include/linux/cpu.h +2 -0
@@ -74,6 +74,8 @@ extern ssize_t cpu_show_spec_rstack_over struct device_attribute *attr, char *buf);extern ssize_t cpu_show_gds (struct device *dev,struct device_attribute *attr,char *buf); +extern ssize_t cpu_show_reg_file_data_sampling (struct device *dev, +struct device_attribute *attr,char *buf); extern __printf(4, 5) struct device *cpu_device_create(struct device *parent, void *drvdata,
Greg Kroah-Hartman
maintainerPATCH 160/690 KVM/x86: Export RFDS_NO and RFDS_CLEAR to guests
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pawan Gupta <[email protected]>
commit 2a0180129d726a4b953232175857d442651b55a0 upstream.
Mitigation for RFDS requires RFDS_CLEAR capability which is enumerated by MSR_IA32_ARCH_CAPABILITIES bit 27. If the host has it set, export it to guests so that they can deploy the mitigation.
RFDS_NO indicates that the system is not vulnerable to RFDS, export it to guests so that they don't deploy the mitigation unnecessarily. When the host is not affected by X86_BUG_RFDS, but has RFDS_NO=0, synthesize RFDS_NO to the guest.
--- arch/x86/kvm/x86.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
arch/x86/kvm/x86.c +4 -1
@@ -1498,7 +1498,8 @@ static unsigned int num_msr_based_featur ARCH_CAP_SKIP_VMENTRY_L1DFLUSH | ARCH_CAP_SSB_NO | ARCH_CAP_MDS_NO | \ ARCH_CAP_PSCHANGE_MC_NO | ARCH_CAP_TSX_CTRL_MSR | ARCH_CAP_TAA_NO | \ ARCH_CAP_SBDR_SSDP_NO | ARCH_CAP_FBSDP_NO | ARCH_CAP_PSDP_NO | \ - ARCH_CAP_FB_CLEAR | ARCH_CAP_RRSBA | ARCH_CAP_PBRSB_NO | ARCH_CAP_GDS_NO) + ARCH_CAP_FB_CLEAR | ARCH_CAP_RRSBA | ARCH_CAP_PBRSB_NO | ARCH_CAP_GDS_NO | \ + ARCH_CAP_RFDS_NO | ARCH_CAP_RFDS_CLEAR)static u64 kvm_get_arch_capabilities (void ) {
@@ -1535,6 +1536,8 @@ static u64 kvm_get_arch_capabilities(voi data |=ARCH_CAP_SSB_NO ;if (!boot_cpu_has_bug (X86_BUG_MDS )) data |=ARCH_CAP_MDS_NO ; +if (!boot_cpu_has_bug (X86_BUG_RFDS )) + data |=ARCH_CAP_RFDS_NO ;if (!boot_cpu_has (X86_FEATURE_RTM )) {/*
Greg Kroah-Hartman
maintainerPATCH 161/690 arch: Introduce CONFIG_FUNCTION_ALIGNMENT
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Peter Zijlstra <[email protected]>
commit d49a0626216b95cd4bf696f6acf55f39a16ab0bb upstream.
Generic function-alignment infrastructure.
Architectures can select FUNCTION_ALIGNMENT_xxB symbols; the FUNCTION_ALIGNMENT symbol is then set to the largest such selected size, 0 otherwise.
Quoted 1 line
From this the -falign-functions compiler argument and
__ALIGNmacro
are set.
This incorporates the DEBUG_FORCE_FUNCTION_ALIGN_64B knob and future alignment requirements for x86_64 (later in this series) into a single place.
NOTE: also removes the 0x90 filler byte from the generic __ALIGN
primitive, that value makes no sense outside of x86.
NOTE: .balign 0 reverts to a no-op.
--- Makefile | 4 ++-- arch/Kconfig | 24 ++++++++++++++++++++++++ arch/ia64/Kconfig | 1 + arch/ia64/Makefile | 2 +- arch/x86/Kconfig | 2 ++ arch/x86/boot/compressed/head_64.S | 8 ++++++++ arch/x86/include/asm/linkage.h | 4 +--- include/asm-generic/vmlinux.lds.h | 4 ++-- include/linux/linkage.h | 4 ++-- lib/Kconfig.debug | 1 + 10 files changed, 44 insertions(+), 10 deletions(-)
Makefile +2 -2
@@ -1000,8 +1000,8 @@ KBUILD_CFLAGS += $(CC_FLAGS_CFI) export CC_FLAGS_CFI endif -ifdef CONFIG_DEBUG_FORCE_FUNCTION_ALIGN_64B -KBUILD_CFLAGS += -falign-functions=64 +ifneq ($(CONFIG_FUNCTION_ALIGNMENT),0) +KBUILD_CFLAGS += -falign-functions=$(CONFIG_FUNCTION_ALIGNMENT) endif # arch Makefile may override CC so keep this after arch Makefile is included
arch/Kconfig +24 -0
@@ -1303,4 +1303,28 @@ source "kernel/gcov/Kconfig" source "scripts/gcc-plugins/Kconfig" +config FUNCTION_ALIGNMENT_4B + bool + +config FUNCTION_ALIGNMENT_8B + bool + +config FUNCTION_ALIGNMENT_16B + bool + +config FUNCTION_ALIGNMENT_32B + bool + +config FUNCTION_ALIGNMENT_64B + bool + +config FUNCTION_ALIGNMENT + int + default 64 if FUNCTION_ALIGNMENT_64B + default 32 if FUNCTION_ALIGNMENT_32B + default 16 if FUNCTION_ALIGNMENT_16B + default 8 if FUNCTION_ALIGNMENT_8B + default 4 if FUNCTION_ALIGNMENT_4B + default 0 + endmenu
arch/ia64/Kconfig +1 -0
@@ -63,6 +63,7 @@ config IA64 select PCI_MSI_ARCH_FALLBACKS if PCI_MSI select SET_FS select ZONE_DMA32 + select FUNCTION_ALIGNMENT_32B default y help The Itanium Processor Family is Intel's 64-bit successor to
arch/ia64/Makefile +1 -1
@@ -23,7 +23,7 @@ KBUILD_AFLAGS_KERNEL := -mconstant-gp EXTRA := cflags-y := -pipe $(EXTRA) -ffixed-r13 -mfixed-range=f12-f15,f32-f127 \ - -falign-functions=32 -frename-registers -fno-optimize-sibling-calls + -frename-registers -fno-optimize-sibling-calls KBUILD_CFLAGS_KERNEL := -mconstant-gp GAS_STATUS = $(shell $(srctree)/arch/ia64/scripts/check-gas "$(CC)" "$(OBJDUMP)")
arch/x86/Kconfig +2 -0
@@ -267,6 +267,8 @@ config X86 select HAVE_ARCH_KCSAN if X86_64 select X86_FEATURE_NAMES if PROC_FS select PROC_PID_ARCH_STATUS if PROC_FS + select FUNCTION_ALIGNMENT_16B if X86_64 || X86_ALIGNMENT_16 + select FUNCTION_ALIGNMENT_4B imply IMA_SECURE_AND_OR_TRUSTED_BOOT if EFI config INSTRUCTION_DECODER
arch/x86/boot/compressed/head_64.S +8 -0
@@ -38,6 +38,14 @@ #include "pgtable.h" /* + * Fix alignment at 16 bytes. Following CONFIG_FUNCTION_ALIGNMENT will result + * in assembly errors due to trying to move .org backward due to the excessive + * alignment. + */ +#undef __ALIGN +#define __ALIGN .balign 16, 0x90 + +/* * Locally defined symbols should be marked hidden: */ .hidden _bss
arch/x86/include/asm/linkage.h +1 -3
@@ -13,10 +13,8 @@#ifdef __ASSEMBLY__ -#if defined(CONFIG_X86_64 ) || defined(CONFIG_X86_ALIGNMENT_16 ) -#define __ALIGN .p2align 4, 0x90 +#define __ALIGN .balign CONFIG_FUNCTION_ALIGNMENT, 0x90;#define __ALIGN_STR __stringify(__ALIGN) -#endif #if defined(CONFIG_RETHUNK ) && !defined(__DISABLE_EXPORTS) && !defined(BUILD_VDSO )#define RET jmp __x86_return_thunk
include/asm-generic/vmlinux.lds.h +2 -2
@@ -81,8 +81,8 @@#define RO_EXCEPTION_TABLE #endif -/* Align . to a 8 byte boundary equals to maximum function alignment. */ -#define ALIGN_FUNCTION () . = ALIGN(8) +/* Align . function alignment. */ +#define ALIGN_FUNCTION () . = ALIGN(CONFIG_FUNCTION_ALIGNMENT)/* * LD_DEAD_CODE_DATA_ELIMINATION option enables -fdata-sections, which
include/linux/linkage.h +2 -2
@@ -69,8 +69,8 @@#endif #ifndef __ALIGN -#define __ALIGN .align 4,0x90 -#define __ALIGN_STR ".align 4,0x90" +#define __ALIGN .balign CONFIG_FUNCTION_ALIGNMENT +#define __ALIGN_STR __stringify(__ALIGN)#endif #ifdef __ASSEMBLY__
lib/Kconfig.debug +1 -0
@@ -424,6 +424,7 @@ config SECTION_MISMATCH_WARN_ONLY config DEBUG_FORCE_FUNCTION_ALIGN_64B bool "Force all function address 64B aligned" depends on EXPERT && (X86_64 || ARM64 || PPC32 || PPC64 || ARC) + select FUNCTION_ALIGNMENT_64B help There are cases that a commit from one domain changes the function address alignment of other domains, and cause magic performance
Greg Kroah-Hartman
maintainerPATCH 162/690 x86/asm: Differentiate between code and function alignment
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Thomas Gleixner <[email protected]>
commit 8eb5d34e77c63fde8af21c691bcf6e3cd87f7829 upstream.
Create SYM_F_ALIGN to differentiate alignment requirements between SYM_CODE and SYM_FUNC.
This distinction is useful later when adding padding in front of functions; IOW this allows following the compiler's patchable-function-entry option.
[peterz: Changelog]
--- arch/x86/include/asm/linkage.h | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
arch/x86/include/asm/linkage.h +6 -2
@@ -11,11 +11,15 @@#define asmlinkage CPP_ASMLINKAGE __attribute__((regparm(0)))#endif /* CONFIG_X86_32 */ -#ifdef __ASSEMBLY__ -#define __ALIGN .balign CONFIG_FUNCTION_ALIGNMENT, 0x90;#define __ALIGN_STR __stringify(__ALIGN) +#define ASM_FUNC_ALIGN __ALIGN_STR +#define __FUNC_ALIGN __ALIGN +#define SYM_F_ALIGN __FUNC_ALIGN + +#ifdef __ASSEMBLY__ +#if defined(CONFIG_RETHUNK ) && !defined(__DISABLE_EXPORTS) && !defined(BUILD_VDSO )#define RET jmp __x86_return_thunk#else /* CONFIG_RETPOLINE */
Greg Kroah-Hartman
maintainerPATCH 163/690 x86/alternatives: Introduce int3_emulate_jcc()
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Peter Zijlstra <[email protected]>
commit db7adcfd1cec4e95155e37bc066fddab302c6340 upstream.
Move the kprobe Jcc emulation into int3_emulate_jcc() so it can be used by more code -- specifically static_call() will need this.
--- arch/x86/include/asm/text-patching.h | 31 ++++++++++++++++++++++++++++ arch/x86/kernel/kprobes/core.c | 38 +++++++---------------------------- 2 files changed, 39 insertions(+), 30 deletions(-)
arch/x86/include/asm/text-patching.h +31 -0
@@ -181,6 +181,37 @@ void int3_emulate_ret(struct pt_regs *reunsigned long ip =int3_emulate_pop (regs);int3_emulate_jmp (regs, ip); } + +static __always_inline +void int3_emulate_jcc(struct pt_regs *regs, u8 cc, unsigned long ip, unsigned long disp) +{ +static const unsigned long jcc_mask[6 ] = { + [0 ] =X86_EFLAGS_OF , + [1 ] =X86_EFLAGS_CF , + [2 ] =X86_EFLAGS_ZF , + [3 ] =X86_EFLAGS_CF |X86_EFLAGS_ZF , + [4 ] =X86_EFLAGS_SF , + [5 ] =X86_EFLAGS_PF , + }; + +bool invert = cc &1 ; +bool match; + +if (cc <0xc ) { + match = regs->flags & jcc_mask[cc >>1 ]; + }else { + match = ((regs->flags &X86_EFLAGS_SF ) >>X86_EFLAGS_SF_BIT ) ^ + ((regs->flags &X86_EFLAGS_OF ) >>X86_EFLAGS_OF_BIT ); +if (cc >=0xe ) + match = match || (regs->flags &X86_EFLAGS_ZF ); + } + +if ((match && !invert) || (!match && invert)) + ip += disp; + +int3_emulate_jmp (regs, ip); +} +#endif /* !CONFIG_UML_X86 */ #endif /* _ASM_X86_TEXT_PATCHING_H */
arch/x86/kernel/kprobes/core.c +8 -30
@@ -463,50 +463,26 @@ static void kprobe_emulate_call(struct k }NOKPROBE_SYMBOL (kprobe_emulate_call); -static nokprobe_inline -void __kprobe_emulate_jmp(struct kprobe *p, struct pt_regs *regs, bool cond) +static void kprobe_emulate_jmp (struct kprobe *p,struct pt_regs *regs) {unsigned long ip = regs->ip -INT3_INSN_SIZE + p->ainsn.size; -if (cond) - ip += p->ainsn.rel32; + ip += p->ainsn.rel32;int3_emulate_jmp (regs, ip); } - -static void kprobe_emulate_jmp (struct kprobe *p,struct pt_regs *regs) -{ -__kprobe_emulate_jmp (p, regs, true); -}NOKPROBE_SYMBOL (kprobe_emulate_jmp); -static const unsigned long jcc_mask[6 ] = { - [0 ] =X86_EFLAGS_OF , - [1 ] =X86_EFLAGS_CF , - [2 ] =X86_EFLAGS_ZF , - [3 ] =X86_EFLAGS_CF |X86_EFLAGS_ZF , - [4 ] =X86_EFLAGS_SF , - [5 ] =X86_EFLAGS_PF , -}; -static void kprobe_emulate_jcc (struct kprobe *p,struct pt_regs *regs) { -bool invert = p->ainsn.jcc.type &1 ; -bool match; +unsigned long ip = regs->ip -INT3_INSN_SIZE + p->ainsn.size; -if (p->ainsn.jcc.type <0xc ) { - match = regs->flags & jcc_mask[p->ainsn.jcc.type >>1 ]; - }else { - match = ((regs->flags &X86_EFLAGS_SF ) >>X86_EFLAGS_SF_BIT ) ^ - ((regs->flags &X86_EFLAGS_OF ) >>X86_EFLAGS_OF_BIT ); -if (p->ainsn.jcc.type >=0xe ) - match = match || (regs->flags &X86_EFLAGS_ZF ); - } -__kprobe_emulate_jmp (p, regs, (match && !invert) || (!match && invert)); +int3_emulate_jcc (regs, p->ainsn.jcc.type, ip, p->ainsn.rel32); }NOKPROBE_SYMBOL (kprobe_emulate_jcc);static void kprobe_emulate_loop (struct kprobe *p,struct pt_regs *regs) { +unsigned long ip = regs->ip -INT3_INSN_SIZE + p->ainsn.size;bool match;if (p->ainsn.loop.type !=3 ) {/* LOOP* */
@@ -534,7 +510,9 @@ static void kprobe_emulate_loop(struct kelse if (p->ainsn.loop.type ==1 )/* LOOPE */ match = match && (regs->flags &X86_EFLAGS_ZF ); -__kprobe_emulate_jmp (p, regs, match); +if (match) + ip += p->ainsn.rel32; +int3_emulate_jmp (regs, ip); }NOKPROBE_SYMBOL (kprobe_emulate_loop);
Greg Kroah-Hartman
maintainerPATCH 164/690 x86/alternatives: Teach text_poke_bp() to patch Jcc.d32 instructions
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Peter Zijlstra <[email protected]>
commit ac0ee0a9560c97fa5fe1409e450c2425d4ebd17a upstream.
In order to re-write Jcc.d32 instructions text_poke_bp() needs to be taught about them.
The biggest hurdle is that the whole machinery is currently made for 5 byte instructions and extending this would grow struct text_poke_loc which is currently a nice 16 bytes and used in an array.
However, since text_poke_loc contains a full copy of the (s32) displacement, it is possible to map the Jcc.d32 2 byte opcodes to Jcc.d8 1 byte opcode for the int3 emulation.
This then leaves the replacement bytes; fudge that by only storing the last 5 bytes and adding the rule that 'length == 6' instruction will be prefixed with a 0x0f byte.
--- arch/x86/kernel/alternative.c | 56 +++++++++++++++++++++++++++++++++++------- 1 file changed, 47 insertions(+), 9 deletions(-)
arch/x86/kernel/alternative.c +47 -9
@@ -351,6 +351,12 @@ next:kasan_enable_current (); } +static inline bool is_jcc32 (struct insn *insn) +{ +/* Jcc.d32 second opcode byte is in the range: 0x80-0x8f */ +return insn->opcode.bytes[0 ] ==0x0f && (insn->opcode.bytes[1 ] &0xf0 ) ==0x80 ; +} +#if defined(CONFIG_RETPOLINE ) && defined(CONFIG_STACK_VALIDATION )/*
@@ -1201,6 +1207,11 @@ void text_poke_sync(void)on_each_cpu (do_sync_core,NULL ,1 ); } +/* +* NOTE: crazy scheme to allow patching Jcc.d32 but not increase the size of +* this thing. When len == 6 everything is prefixed with 0x0f and we map +* opcode to Jcc.d8, using len to distinguish. +*/ struct text_poke_loc {/* addr := _stext + rel_addr */ s32 rel_addr;
@@ -1322,6 +1333,10 @@ noinstr int poke_int3_handler(struct pt_int3_emulate_jmp (regs, (long )ip + tp->disp);break ; + case 0x70 ... 0x7f: /* Jcc */ +int3_emulate_jcc (regs, tp->opcode &0xf , (long )ip, tp->disp); +break ; +default :BUG (); }
@@ -1395,16 +1410,26 @@ static void text_poke_bp_batch(struct te* Second step: update all but the first byte of the patched range. */ for (do_sync =0 , i =0 ; i < nr_entries; i++) { -u8 old[POKE_MAX_OPCODE_SIZE ] = { tp[i].old, }; +u8 old[POKE_MAX_OPCODE_SIZE +1 ] = { tp[i].old, }; +u8 _new[POKE_MAX_OPCODE_SIZE +1 ]; +const u8 *new = tp[i].text;int len = tp[i].len;if (len -INT3_INSN_SIZE >0 ) {memcpy (old +INT3_INSN_SIZE ,text_poke_addr (&tp[i]) +INT3_INSN_SIZE , len -INT3_INSN_SIZE ); + +if (len ==6 ) { + _new[0 ] =0x0f ; +memcpy (_new +1 , new,5 ); + new = _new; + } +text_poke (text_poke_addr (&tp[i]) +INT3_INSN_SIZE , - (const char *)tp[i].text +INT3_INSN_SIZE , + new +INT3_INSN_SIZE , len -INT3_INSN_SIZE ); + do_sync++; }
@@ -1432,8 +1457,7 @@ static void text_poke_bp_batch(struct te* The old instruction is recorded so that the event can be * processed forwards or backwards. */ -perf_event_text_poke (text_poke_addr (&tp[i]), old, len, - tp[i].text, len); +perf_event_text_poke (text_poke_addr (&tp[i]), old, len, new, len); }if (do_sync) {
@@ -1450,10 +1474,15 @@ static void text_poke_bp_batch(struct te* replacing opcode. */ for (do_sync =0 , i =0 ; i < nr_entries; i++) { -if (tp[i].text[0 ] ==INT3_INSN_OPCODE ) +u8 byte = tp[i].text[0 ]; + +if (tp[i].len ==6 ) + byte =0x0f ; + +if (byte ==INT3_INSN_OPCODE )continue ; -text_poke (text_poke_addr (&tp[i]), tp[i].text,INT3_INSN_SIZE ); +text_poke (text_poke_addr (&tp[i]), &byte,INT3_INSN_SIZE ); do_sync++; }
@@ -1471,9 +1500,11 @@ static void text_poke_loc_init(struct te const void *opcode, size_t len, const void *emulate) { struct insn insn; -int ret, i; +int ret, i =0 ; -memcpy ((void *)tp->text, opcode, len); +if (len ==6 ) + i =1 ; +memcpy ((void *)tp->text, opcode+i, len-i);if (!emulate) emulate = opcode;
@@ -1484,6 +1515,13 @@ static void text_poke_loc_init(struct te tp->len = len; tp->opcode = insn.opcode.bytes[0 ]; +if (is_jcc32 (&insn)) { +/* +* Map Jcc.d32 onto Jcc.d8 and use len to distinguish. +*/ + tp->opcode = insn.opcode.bytes[1 ] -0x10 ; + } +switch (tp->opcode) {case RET_INSN_OPCODE :case JMP32_INSN_OPCODE :
@@ -1500,7 +1538,6 @@ static void text_poke_loc_init(struct teBUG_ON (len != insn.length); }; -switch (tp->opcode) {case INT3_INSN_OPCODE :case RET_INSN_OPCODE :
@@ -1509,6 +1546,7 @@ static void text_poke_loc_init(struct tecase CALL_INSN_OPCODE :case JMP32_INSN_OPCODE :case JMP8_INSN_OPCODE : + case 0x70 ... 0x7f: /* Jcc */ tp->disp = insn.immediate.value;break ;
Greg Kroah-Hartman
maintainerPATCH 165/690 x86/static_call: Add support for Jcc tail-calls
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Peter Zijlstra <[email protected]>
commit 923510c88d2b7d947c4217835fd9ca6bd65cc56c upstream.
Clang likes to create conditional tail calls like:
0000000000000350 <amd_pmu_add_event>:
350: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) 351: R_X86_64_NONE __fentry__-0x4 355: 48 83 bf 20 01 00 00 00 cmpq $0x0,0x120(%rdi) 35d: 0f 85 00 00 00 00 jne 363 <amd_pmu_add_event+0x13> 35f: R_X86_64_PLT32 __SCT__amd_pmu_branch_add-0x4 363: e9 00 00 00 00 jmp 368 <amd_pmu_add_event+0x18> 364: R_X86_64_PLT32 __x86_return_thunk-0x4
Where 0x35d is a static call site that's turned into a conditional tail-call using the Jcc class of instructions.
Teach the in-line static call text patching about this.
Notably, since there is no conditional-ret, in that case patch the Jcc to point at an empty stub function that does the ret -- or the return thunk when needed.
--- arch/x86/kernel/static_call.c | 50 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 47 insertions(+), 3 deletions(-)
arch/x86/kernel/static_call.c +47 -3
@@ -9,6 +9,7 @@ enum insn_type {NOP =1 ,/* site cond-call */ JMP =2 ,/* tramp / site tail-call */ RET =3 ,/* tramp / site cond-tail-call */ + JCC = 4, };/*
@@ -25,12 +26,40 @@ static const u8 xor5rax[] = { 0x2e, 0x2estatic const u8 retinsn[] = {RET_INSN_OPCODE ,0xcc ,0xcc ,0xcc ,0xcc }; +static u8 __is_Jcc (u8 *insn)/* Jcc.d32 */ +{ +u8 ret =0 ; + +if (insn[0 ] ==0x0f ) { +u8 tmp = insn[1 ]; +if ((tmp &0xf0 ) ==0x80 ) + ret = tmp; + } + +return ret; +} + +extern void __static_call_return (void ); + +asm (".global __static_call_return\n\t" +".type __static_call_return, @function\n\t" +ASM_FUNC_ALIGN "\n\t" +"__static_call_return:\n\t" +ANNOTATE_NOENDBR +ANNOTATE_RETPOLINE_SAFE +"ret; int3\n\t" +".size __static_call_return, . - __static_call_return \n\t" ); +static void __ref __static_call_transform (void *insn,enum insn_type type,void *func,bool modinit) {const void *emulate =NULL ;int size =CALL_INSN_SIZE ;const void *code; +u8 op, buf[6 ]; + +if ((type ==JMP || type ==RET ) && (op =__is_Jcc (insn))) + type =JCC ;switch (type) {case CALL :
@@ -56,6 +85,20 @@ static void __ref __static_call_transforelse code = &retinsn;break ; + +case JCC : +if (!func) { + func = __static_call_return; +if (cpu_feature_enabled (X86_FEATURE_RETHUNK )) + func = x86_return_thunk; + } + + buf[0 ] =0x0f ; +__text_gen_insn (buf+1 , op, insn+1 , func,5 ); + code = buf; + size =6 ; + +break ; }if (memcmp (insn, code, size) ==0 )
@@ -67,13 +110,14 @@ static void __ref __static_call_transfortext_poke_bp (insn, code, size, emulate); } -static void __static_call_validate (void *insn,bool tail) +static void __static_call_validate (u8 *insn,bool tail) { -u8 opcode = *(u8 *)insn; +u8 opcode = insn[0 ];if (tail) {if (opcode ==JMP32_INSN_OPCODE || - opcode ==RET_INSN_OPCODE ) + opcode ==RET_INSN_OPCODE || +__is_Jcc (insn))return ; }else { if (opcode == CALL_INSN_OPCODE ||
Greg Kroah-Hartman
maintainerPATCH 166/690 fsnotify: pass data_type to fsnotify_name()
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Amir Goldstein <[email protected]>
[ Upstream commit 9baf93d68bcc3d0a6042283b82603c076e25e4f5 ]
Align the arguments of fsnotify_name() to those of fsnotify().
--- include/linux/fsnotify.h | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-)
include/linux/fsnotify.h +13 -9
@@ -26,20 +26,21 @@* FS_EVENT_ON_CHILD mask on the parent inode and will not be reported if only * the child is interested and not the parent. */ -static inline void fsnotify_name (struct inode *dir,__u32 mask, -struct inode *child, -const struct qstr *name,u32 cookie) +static inline int fsnotify_name (__u32 mask,const void *data,int data_type, +struct inode *dir,const struct qstr *name, +u32 cookie) {if (atomic_long_read (&dir->i_sb->s_fsnotify_connectors) ==0 ) -return ; +return 0 ; -fsnotify (mask, child,FSNOTIFY_EVENT_INODE , dir, name,NULL , cookie); +return fsnotify (mask, data, data_type, dir, name,NULL , cookie); }static inline void fsnotify_dirent (struct inode *dir,struct dentry *dentry,__u32 mask) { -fsnotify_name (dir, mask,d_inode (dentry), &dentry->d_name,0 ); +fsnotify_name (mask,d_inode (dentry),FSNOTIFY_EVENT_INODE , + dir, &dentry->d_name,0 ); }static inline void fsnotify_inode (struct inode *inode,__u32 mask)
@@ -154,8 +155,10 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir, new_dir_mask |=FS_ISDIR ; } -fsnotify_name (old_dir, old_dir_mask, source, old_name, fs_cookie); -fsnotify_name (new_dir, new_dir_mask, source, new_name, fs_cookie); +fsnotify_name (old_dir_mask, source,FSNOTIFY_EVENT_INODE , + old_dir, old_name, fs_cookie); +fsnotify_name (new_dir_mask, source,FSNOTIFY_EVENT_INODE , + new_dir, new_name, fs_cookie);if (target)fsnotify_link_count (target);
@@ -209,7 +212,8 @@ static inline void fsnotify_link(struct inode *dir, struct inode *inode,fsnotify_link_count (inode);audit_inode_child (dir, new_dentry,AUDIT_TYPE_CHILD_CREATE ); -fsnotify_name (dir,FS_CREATE , inode, &new_dentry->d_name,0 ); +fsnotify_name (FS_CREATE , inode,FSNOTIFY_EVENT_INODE , + dir, &new_dentry->d_name,0 ); }/*
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 167/690 fsnotify: pass dentry instead of inode data
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Amir Goldstein <[email protected]>
[ Upstream commit fd5a3ff49a19aa69e2bc1e26e98037c2d778e61a ]
Define a new data type to pass for event - FSNOTIFY_EVENT_DENTRY. Use it to pass the dentry instead of it's ->d_inode where available.
This is needed in preparation to the refactor to retrieve the super block from the data field. In some cases (i.e. mkdir in kernfs), the data inode comes from a negative dentry, such that no super block information would be available. By receiving the dentry itself, instead of the inode, fsnotify can derive the super block even on these cases.
--- include/linux/fsnotify.h | 5 ++--- include/linux/fsnotify_backend.h | 16 ++++++++++++++++ 2 files changed, 18 insertions(+), 3 deletions(-)
include/linux/fsnotify.h +2 -3
@@ -39,8 +39,7 @@ static inline int fsnotify_name(__u32 mask, const void *data, int data_type,static inline void fsnotify_dirent (struct inode *dir,struct dentry *dentry,__u32 mask) { -fsnotify_name (mask,d_inode (dentry),FSNOTIFY_EVENT_INODE , - dir, &dentry->d_name,0 ); +fsnotify_name (mask, dentry,FSNOTIFY_EVENT_DENTRY , dir, &dentry->d_name,0 ); }static inline void fsnotify_inode (struct inode *inode,__u32 mask)
@@ -87,7 +86,7 @@ static inline int fsnotify_parent(struct dentry *dentry, __u32 mask,*/ static inline void fsnotify_dentry (struct dentry *dentry,__u32 mask) { -fsnotify_parent (dentry, mask,d_inode (dentry),FSNOTIFY_EVENT_INODE ); +fsnotify_parent (dentry, mask, dentry,FSNOTIFY_EVENT_DENTRY ); }static inline int fsnotify_file (struct file *file,__u32 mask)
include/linux/fsnotify_backend.h +16 -0
@@ -248,6 +248,7 @@ enum fsnotify_data_type {FSNOTIFY_EVENT_NONE ,FSNOTIFY_EVENT_PATH ,FSNOTIFY_EVENT_INODE , + FSNOTIFY_EVENT_DENTRY, };static inline struct inode *fsnotify_data_inode (const void *data,int data_type)
@@ -255,6 +256,8 @@ static inline struct inode *fsnotify_data_inode(const void *data, int data_type)switch (data_type) {case FSNOTIFY_EVENT_INODE :return (struct inode *)data; +case FSNOTIFY_EVENT_DENTRY : +return d_inode (data);case FSNOTIFY_EVENT_PATH :return d_inode (((const struct path *)data)->dentry);default :
@@ -262,6 +265,19 @@ static inline struct inode *fsnotify_data_inode(const void *data, int data_type) } } +static inline struct dentry *fsnotify_data_dentry (const void *data,int data_type) +{ +switch (data_type) { +case FSNOTIFY_EVENT_DENTRY : +/* Non const is needed for dget() */ +return (struct dentry *)data; +case FSNOTIFY_EVENT_PATH : +return ((const struct path *)data)->dentry; +default : +return NULL ; + } +} +static inline const struct path *fsnotify_data_path (const void *data,int data_type) {
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 168/690 fsnotify: clarify contract for create event hooks
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Amir Goldstein <[email protected]>
[ Upstream commit dabe729dddca550446e9cc118c96d1f91703345b ]
Clarify argument names and contract for fsnotify_create() and fsnotify_mkdir() to reflect the anomaly of kernfs, which leaves dentries negavite after mkdir/create.
Remove the WARN_ON(!inode) in audit code that were added by the Fixes commit under the wrong assumption that dentries cannot be negative after mkdir/create.
--- include/linux/fsnotify.h | 22 ++++++++++++++++------ kernel/audit_fsnotify.c | 3 +-- kernel/audit_watch.c | 3 +-- 3 files changed, 18 insertions(+), 10 deletions(-)
include/linux/fsnotify.h +16 -6
@@ -192,16 +192,22 @@ static inline void fsnotify_inoderemove(struct inode *inode)/* * fsnotify_create - 'name' was linked in +* +* Caller must make sure that dentry->d_name is stable. +* Note: some filesystems (e.g. kernfs) leave @dentry negative and instantiate +* ->d_inode later */ -static inline void fsnotify_create (struct inode *inode,struct dentry *dentry) +static inline void fsnotify_create (struct inode *dir,struct dentry *dentry) { -audit_inode_child (inode, dentry,AUDIT_TYPE_CHILD_CREATE ); +audit_inode_child (dir, dentry,AUDIT_TYPE_CHILD_CREATE ); -fsnotify_dirent (inode, dentry,FS_CREATE ); +fsnotify_dirent (dir, dentry,FS_CREATE ); }/* * fsnotify_link - new hardlink in 'inode' directory +* +* Caller must make sure that new_dentry->d_name is stable. * Note: We have to pass also the linked inode ptr as some filesystems leave * new_dentry->d_inode NULL and instantiate inode pointer later */
@@ -266,12 +272,16 @@ static inline void fsnotify_unlink(struct inode *dir, struct dentry *dentry)/* * fsnotify_mkdir - directory 'name' was created +* +* Caller must make sure that dentry->d_name is stable. +* Note: some filesystems (e.g. kernfs) leave @dentry negative and instantiate +* ->d_inode later */ -static inline void fsnotify_mkdir (struct inode *inode,struct dentry *dentry) +static inline void fsnotify_mkdir (struct inode *dir,struct dentry *dentry) { -audit_inode_child (inode, dentry,AUDIT_TYPE_CHILD_CREATE ); +audit_inode_child (dir, dentry,AUDIT_TYPE_CHILD_CREATE ); -fsnotify_dirent (inode, dentry,FS_CREATE |FS_ISDIR ); +fsnotify_dirent (dir, dentry,FS_CREATE |FS_ISDIR ); }/*
kernel/audit_fsnotify.c +1 -2
@@ -161,8 +161,7 @@ static int audit_mark_handle_event(struct fsnotify_mark *inode_mark, u32 mask, audit_mark = container_of(inode_mark, struct audit_fsnotify_mark, mark); -if (WARN_ON_ONCE (inode_mark->group != audit_fsnotify_group) || -WARN_ON_ONCE (!inode)) +if (WARN_ON_ONCE (inode_mark->group != audit_fsnotify_group))return 0 ;if (mask & (FS_CREATE |FS_MOVED_TO |FS_DELETE |FS_MOVED_FROM )) {
kernel/audit_watch.c +1 -2
@@ -472,8 +472,7 @@ static int audit_watch_handle_event(struct fsnotify_mark *inode_mark, u32 mask, parent = container_of(inode_mark, struct audit_parent, mark); -if (WARN_ON_ONCE (inode_mark->group != audit_watch_group) || -WARN_ON_ONCE (!inode)) +if (WARN_ON_ONCE (inode_mark->group != audit_watch_group))return 0 ;if (mask & (FS_CREATE |FS_MOVED_TO ) && inode)
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 169/690 fsnotify: Dont insert unmergeable events in hashtable
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit cc53b55f697fe5aa98bdbfdfe67c6401da242155 ]
Some events, like the overflow event, are not mergeable, so they are not hashed. But, when failing inside fsnotify_add_event for lack of space, fsnotify_add_event() still calls the insert hook, which adds the overflow event to the merge list. Add a check to prevent any kind of unmergeable event to be inserted in the hashtable.
--- fs/notify/fanotify/fanotify.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/notify/fanotify/fanotify.c +4 -2
@@ -702,6 +702,9 @@ static void fanotify_insert_event(struct fsnotify_group *group,assert_spin_locked (&group->notification_lock); +if (!fanotify_is_hashed_event (event->mask)) +return ; +pr_debug ("%s: group=%p event=%p bucket=%u\n" , __func__, group, event, bucket);
@@ -779,8 +782,7 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask, fsn_event = &event->fse; ret =fsnotify_add_event (group, fsn_event, fanotify_merge, -fanotify_is_hashed_event (mask) ? - fanotify_insert_event :NULL ); + fanotify_insert_event);if (ret) {/* Permission events shouldn't be merged */ BUG_ON (ret ==1 && mask &FANOTIFY_PERM_EVENTS );
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 170/690 fanotify: Fold event size calculation to its own function
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit b9928e80dda84b349ba8de01780b9bef2fc36ffa ]
Every time this function is invoked, it is immediately added to FAN_EVENT_METADATA_LEN, since there is no need to just calculate the length of info records. This minor clean up folds the rest of the calculation into the function, which now operates in terms of events, returning the size of the entire event, including metadata.
--- fs/notify/fanotify/fanotify_user.c | 35 +++++++++++++++++------------- 1 file changed, 20 insertions(+), 15 deletions(-)
fs/notify/fanotify/fanotify_user.c +20 -15
@@ -126,17 +126,24 @@ static int fanotify_fid_info_len(int fh_len, int name_len) FANOTIFY_EVENT_ALIGN); } -static int fanotify_event_info_len (unsigned int info_mode, -struct fanotify_event *event) +static size_t fanotify_event_len (unsigned int info_mode, +struct fanotify_event *event) { -struct fanotify_info *info =fanotify_event_info (event); -int dir_fh_len =fanotify_event_dir_fh_len (event); -int fh_len =fanotify_event_object_fh_len (event); -int info_len =0 ; +size_t event_len =FAN_EVENT_METADATA_LEN ; +struct fanotify_info *info; +int dir_fh_len; +int fh_len;int dot_len =0 ; +if (!info_mode) +return event_len; + + info =fanotify_event_info (event); + dir_fh_len =fanotify_event_dir_fh_len (event); + fh_len =fanotify_event_object_fh_len (event); +if (dir_fh_len) { - info_len +=fanotify_fid_info_len (dir_fh_len, info->name_len); + event_len +=fanotify_fid_info_len (dir_fh_len, info->name_len); }else if ((info_mode &FAN_REPORT_NAME ) && (event->mask &FAN_ONDIR )) {/*
@@ -147,12 +154,12 @@ static int fanotify_event_info_len(unsigned int info_mode, }if (info_mode &FAN_REPORT_PIDFD ) - info_len +=FANOTIFY_PIDFD_INFO_HDR_LEN ; + event_len +=FANOTIFY_PIDFD_INFO_HDR_LEN ;if (fh_len) - info_len +=fanotify_fid_info_len (fh_len, dot_len); + event_len +=fanotify_fid_info_len (fh_len, dot_len); -return info_len; +return event_len; }/*
@@ -181,7 +188,7 @@ static void fanotify_unhash_event(struct fsnotify_group *group,static struct fanotify_event *get_one_event (struct fsnotify_group *group,size_t count) { -size_t event_size =FAN_EVENT_METADATA_LEN ; +size_t event_size;struct fanotify_event *event =NULL ;struct fsnotify_event *fsn_event;unsigned int info_mode =FAN_GROUP_FLAG (group,FANOTIFY_INFO_MODES );
@@ -194,8 +201,7 @@ static struct fanotify_event *get_one_event(struct fsnotify_group *group, goto out; event =FANOTIFY_E (fsn_event); -if (info_mode) - event_size +=fanotify_event_info_len (info_mode, event); + event_size =fanotify_event_len (info_mode, event);if (event_size > count) { event =ERR_PTR (-EINVAL );
@@ -537,8 +543,7 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,pr_debug ("%s: group=%p event=%p\n" , __func__, group, event); - metadata.event_len =FAN_EVENT_METADATA_LEN + -fanotify_event_info_len (info_mode, event); + metadata.event_len =fanotify_event_len (info_mode, event); metadata.metadata_len =FAN_EVENT_METADATA_LEN ; metadata.vers =FANOTIFY_METADATA_VERSION ; metadata.reserved =0 ;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 171/690 fanotify: Split fsid check from other fid mode checks
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 8299212cbdb01a5867e230e961f82e5c02a6de34 ]
FAN_FS_ERROR will require fsid, but not necessarily require the filesystem to expose a file handle. Split those checks into different functions, so they can be used separately when setting up an event.
While there, update a comment about tmpfs having 0 fsid, which is no longer true.
--- fs/notify/fanotify/fanotify_user.c | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-)
fs/notify/fanotify/fanotify_user.c +18 -9
@@ -1300,16 +1300,15 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)return fd; } -/* Check if filesystem can encode a unique fid */ -static int fanotify_test_fid (struct path *path,__kernel_fsid_t *fsid) +static int fanotify_test_fsid (struct dentry *dentry,__kernel_fsid_t *fsid) {__kernel_fsid_t root_fsid;int err;/* -* Make sure path is not in filesystem with zero fsid (e.g. tmpfs). +* Make sure dentry is not of a filesystem with zero fsid (e.g. fuse). */ - err =vfs_get_fsid (path->dentry, fsid); + err =vfs_get_fsid (dentry, fsid);if (err)return err;
@@ -1317,10 +1316,10 @@ static int fanotify_test_fid(struct path *path, __kernel_fsid_t *fsid)return -ENODEV ;/* -* Make sure path is not inside a filesystem subvolume (e.g. btrfs) +* Make sure dentry is not of a filesystem subvolume (e.g. btrfs) * which uses a different fsid than sb root. */ - err =vfs_get_fsid (path->dentry->d_sb->s_root, &root_fsid); + err =vfs_get_fsid (dentry->d_sb->s_root, &root_fsid);if (err)return err;
@@ -1328,6 +1327,12 @@ static int fanotify_test_fid(struct path *path, __kernel_fsid_t *fsid) root_fsid.val[1] != fsid->val[1])return -EXDEV ; +return 0 ; +} + +/* Check if filesystem can encode a unique fid */ +static int fanotify_test_fid (struct dentry *dentry) +{/* * We need to make sure that the file system supports at least * encoding a file handle so user can use name_to_handle_at() to
@@ -1335,8 +1340,8 @@ static int fanotify_test_fid(struct path *path, __kernel_fsid_t *fsid)* objects. However, name_to_handle_at() requires that the * filesystem also supports decoding file handles. */ -if (!path->dentry->d_sb->s_export_op || - !path->dentry->d_sb->s_export_op->fh_to_dentry) +if (!dentry->d_sb->s_export_op || + !dentry->d_sb->s_export_op->fh_to_dentry)return -EOPNOTSUPP ;return 0 ;
@@ -1505,7 +1510,11 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, }if (fid_mode) { - ret =fanotify_test_fid (&path, &__fsid); + ret =fanotify_test_fsid (path.dentry, &__fsid); +if (ret) + goto path_put_and_out; + + ret =fanotify_test_fid (path.dentry);if (ret) goto path_put_and_out;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 172/690 inotify: Dont force FS_IN_IGNORED
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit e0462f91d24756916fded4313d508e0fc52f39c9 ]
According to Amir:
"FS_IN_IGNORED is completely internal to inotify and there is no need to set it in i_fsnotify_mask at all, so if we remove the bit from the output of inotify_arg_to_mask() no functionality will change and we will be able to overload the event bit for FS_ERROR."
This is done in preparation to overload FS_ERROR with the notification mechanism in fanotify.
--- fs/notify/inotify/inotify_user.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/notify/inotify/inotify_user.c +3 -3
@@ -94,10 +94,10 @@ static inline __u32 inotify_arg_to_mask(struct inode *inode, u32 arg)__u32 mask;/* -* Everything should accept their own ignored and should receive events -* when the inode is unmounted. All directories care about children. +* Everything should receive events when the inode is unmounted. +* All directories care about children. */ - mask = (FS_IN_IGNORED |FS_UNMOUNT ); + mask = (FS_UNMOUNT );if (S_ISDIR (inode->i_mode)) mask |=FS_EVENT_ON_CHILD ;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 173/690 fsnotify: Add helper to detect overflow_event
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 808967a0a4d2f4ce6a2005c5692fffbecaf018c1 ]
Similarly to fanotify_is_perm_event and friends, provide a helper predicate to say whether a mask is of an overflow event.
--- fs/notify/fanotify/fanotify.h | 3 ++- include/linux/fsnotify_backend.h | 5 +++++ 2 files changed, 7 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.h +2 -1
@@ -315,7 +315,8 @@ static inline struct path *fanotify_event_path(struct fanotify_event *event)*/ static inline bool fanotify_is_hashed_event (u32 mask) { -return !fanotify_is_perm_event (mask) && !(mask &FS_Q_OVERFLOW ); +return !(fanotify_is_perm_event (mask) || +fsnotify_is_overflow_event (mask)); } static inline unsigned int fanotify_event_hash_bucket(
include/linux/fsnotify_backend.h +5 -0
@@ -510,6 +510,11 @@ static inline void fsnotify_queue_overflow(struct fsnotify_group *group)fsnotify_add_event (group, group->overflow_event,NULL ,NULL ); } +static inline bool fsnotify_is_overflow_event (u32 mask) +{ +return mask &FS_Q_OVERFLOW ; +} +static inline bool fsnotify_notify_queue_is_empty (struct fsnotify_group *group) {assert_spin_locked (&group->notification_lock);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 174/690 fsnotify: Add wrapper around fsnotify_add_event
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 1ad03c3a326a86e259389592117252c851873395 ]
fsnotify_add_event is growing in number of parameters, which in most case are just passed a NULL pointer. So, split out a new fsnotify_insert_event function to clean things up for users who don't need an insert hook.
--- fs/notify/fanotify/fanotify.c | 4 ++-- fs/notify/inotify/inotify_fsnotify.c | 2 +- fs/notify/notification.c | 12 ++++++------ include/linux/fsnotify_backend.h | 23 ++++++++++++++++------- 4 files changed, 25 insertions(+), 16 deletions(-)
fs/notify/fanotify/fanotify.c +2 -2
@@ -781,8 +781,8 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask, } fsn_event = &event->fse; - ret =fsnotify_add_event (group, fsn_event, fanotify_merge, - fanotify_insert_event); + ret =fsnotify_insert_event (group, fsn_event, fanotify_merge, + fanotify_insert_event);if (ret) {/* Permission events shouldn't be merged */ BUG_ON (ret ==1 && mask &FANOTIFY_PERM_EVENTS );
fs/notify/inotify/inotify_fsnotify.c +1 -1
@@ -123,7 +123,7 @@ int inotify_handle_inode_event(struct fsnotify_mark *inode_mark, u32 mask,if (len)strcpy (event->name, name->name); - ret =fsnotify_add_event (group, fsn_event, inotify_merge,NULL ); + ret =fsnotify_add_event (group, fsn_event, inotify_merge);if (ret) {/* Our event wasn't used in the end. Free it. */ fsnotify_destroy_event (group, fsn_event);
fs/notify/notification.c +6 -6
@@ -78,12 +78,12 @@ void fsnotify_destroy_event(struct fsnotify_group *group,* 2 if the event was not queued - either the queue of events has overflown * or the group is shutting down. */ -int fsnotify_add_event (struct fsnotify_group *group, -struct fsnotify_event *event, -int (*merge)(struct fsnotify_group *, -struct fsnotify_event *), -void (*insert)(struct fsnotify_group *, -struct fsnotify_event *)) +int fsnotify_insert_event (struct fsnotify_group *group, +struct fsnotify_event *event, +int (*merge)(struct fsnotify_group *, +struct fsnotify_event *), +void (*insert)(struct fsnotify_group *, +struct fsnotify_event *)) {int ret =0 ;struct list_head *list = &group->notification_list;
include/linux/fsnotify_backend.h +16 -7
@@ -498,16 +498,25 @@ extern int fsnotify_fasync(int fd, struct file *file, int on);extern void fsnotify_destroy_event (struct fsnotify_group *group,struct fsnotify_event *event);/* attach the event to the group notification queue */ -extern int fsnotify_add_event (struct fsnotify_group *group, -struct fsnotify_event *event, -int (*merge)(struct fsnotify_group *, -struct fsnotify_event *), -void (*insert)(struct fsnotify_group *, -struct fsnotify_event *)); +extern int fsnotify_insert_event (struct fsnotify_group *group, +struct fsnotify_event *event, +int (*merge)(struct fsnotify_group *, +struct fsnotify_event *), +void (*insert)(struct fsnotify_group *, +struct fsnotify_event *)); + +static inline int fsnotify_add_event (struct fsnotify_group *group, +struct fsnotify_event *event, +int (*merge)(struct fsnotify_group *, +struct fsnotify_event *)) +{ +return fsnotify_insert_event (group, event, merge,NULL ); +} +/* Queue overflow event to a notification group */ static inline void fsnotify_queue_overflow (struct fsnotify_group *group) { -fsnotify_add_event (group, group->overflow_event,NULL ,NULL ); +fsnotify_add_event (group, group->overflow_event,NULL ); }static inline bool fsnotify_is_overflow_event (u32 mask)
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 175/690 fsnotify: Retrieve super block from the data field
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 29335033c574a15334015d8c4e36862cff3d3384 ]
Some file system events (i.e. FS_ERROR) might not be associated with an inode or directory. For these, we can retrieve the super block from the data field. But, since the super_block is available in the data field on every event type, simplify the code to always retrieve it from there, through a new helper.
--- fs/notify/fsnotify.c | 7 +++---- include/linux/fsnotify_backend.h | 15 +++++++++++++++ 2 files changed, 18 insertions(+), 4 deletions(-)
fs/notify/fsnotify.c +3 -4
@@ -455,16 +455,16 @@ static void fsnotify_iter_next(struct fsnotify_iter_info *iter_info)* @file_name is relative to * @file_name: optional file name associated with event * @inode: optional inode associated with event - -* either @dir or @inode must be non-NULL. -* if both are non-NULL event may be reported to both. +* If @dir and @inode are both non-NULL, event may be +* reported to both. * @cookie: inotify rename cookie */ int fsnotify (__u32 mask,const void *data,int data_type,struct inode *dir,const struct qstr *file_name,struct inode *inode,u32 cookie) {const struct path *path =fsnotify_data_path (data, data_type); +struct super_block *sb =fsnotify_data_sb (data, data_type);struct fsnotify_iter_info iter_info = {}; -struct super_block *sb;struct mount *mnt =NULL ;struct inode *parent =NULL ;int ret =0 ;
@@ -483,7 +483,6 @@ int fsnotify(__u32 mask, const void *data, int data_type, struct inode *dir,*/ parent = dir; } - sb = inode->i_sb;/* * Optimization: srcu_read_lock() has a memory barrier which can
include/linux/fsnotify_backend.h +15 -0
@@ -289,6 +289,21 @@ static inline const struct path *fsnotify_data_path(const void *data, } } +static inline struct super_block *fsnotify_data_sb (const void *data, +int data_type) +{ +switch (data_type) { +case FSNOTIFY_EVENT_INODE : +return ((struct inode *)data)->i_sb; +case FSNOTIFY_EVENT_DENTRY : +return ((struct dentry *)data)->d_sb; +case FSNOTIFY_EVENT_PATH : +return ((const struct path *)data)->dentry->d_sb; +default : +return NULL ; + } +} +enum fsnotify_obj_type {FSNOTIFY_OBJ_TYPE_INODE ,FSNOTIFY_OBJ_TYPE_PARENT ,
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 176/690 fsnotify: Protect fsnotify_handle_inode_event from no-inode events
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 24dca90590509a7a6cbe0650100c90c5b8a3468a ]
FAN_FS_ERROR allows events without inodes - i.e. for file system-wide errors. Even though fsnotify_handle_inode_event is not currently used by fanotify, this patch protects other backends from cases where neither inode or dir are provided. Also document the constraints of the interface (inode and dir cannot be both NULL).
--- fs/nfsd/filecache.c | 3 +++ fs/notify/fsnotify.c | 3 +++ include/linux/fsnotify_backend.h | 1 + 3 files changed, 7 insertions(+)
fs/nfsd/filecache.c +3 -0
@@ -595,6 +595,9 @@ nfsd_file_fsnotify_handle_event(struct fsnotify_mark *mark, u32 mask, struct inode *inode, struct inode *dir, const struct qstr *name, u32 cookie) { + if (WARN_ON_ONCE(!inode)) + return 0; + trace_nfsd_file_fsnotify_handle_event(inode, mask);/* Should be no marks on non-regular files */
fs/notify/fsnotify.c +3 -0
@@ -252,6 +252,9 @@ static int fsnotify_handle_inode_event(struct fsnotify_group *group,if (WARN_ON_ONCE (!ops->handle_inode_event))return 0 ; +if (WARN_ON_ONCE (!inode && !dir)) +return 0 ; +if ((inode_mark->mask &FS_EXCL_UNLINK ) && path &&d_unlinked (path->dentry))return 0 ;
include/linux/fsnotify_backend.h +1 -0
@@ -136,6 +136,7 @@ struct mem_cgroup;* @dir: optional directory associated with event - * if @file_name is not NULL, this is the directory that * @file_name is relative to. +* Either @inode or @dir must be non-NULL. * @file_name: optional file name associated with event * @cookie: inotify rename cookie *
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 177/690 fsnotify: Pass group argument to free_event
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 330ae77d2a5b0af32c0f29e139bf28ec8591de59 ]
For group-wide mempool backed events, like FS_ERROR, the free_event callback will need to reference the group's mempool to free the memory. Wire that argument into the current callers.
--- fs/notify/fanotify/fanotify.c | 3 ++- fs/notify/group.c | 2 +- fs/notify/inotify/inotify_fsnotify.c | 3 ++- fs/notify/notification.c | 2 +- include/linux/fsnotify_backend.h | 2 +- 5 files changed, 7 insertions(+), 5 deletions(-)
fs/notify/fanotify/fanotify.c +2 -1
@@ -835,7 +835,8 @@ static void fanotify_free_name_event(struct fanotify_event *event)kfree (FANOTIFY_NE (event)); } -static void fanotify_free_event (struct fsnotify_event *fsn_event) +static void fanotify_free_event (struct fsnotify_group *group, +struct fsnotify_event *fsn_event) {struct fanotify_event *event;
fs/notify/group.c +1 -1
@@ -88,7 +88,7 @@ void fsnotify_destroy_group(struct fsnotify_group *group)* that deliberately ignores overflow events. */ if (group->overflow_event) - group->ops->free_event (group->overflow_event); + group->ops->free_event (group, group->overflow_event);fsnotify_put_group (group); }
fs/notify/inotify/inotify_fsnotify.c +2 -1
@@ -184,7 +184,8 @@ static void inotify_free_group_priv(struct fsnotify_group *group)dec_inotify_instances (group->inotify_data.ucounts); } -static void inotify_free_event (struct fsnotify_event *fsn_event) +static void inotify_free_event (struct fsnotify_group *group, +struct fsnotify_event *fsn_event) {kfree (INOTIFY_E (fsn_event)); }
fs/notify/notification.c +1 -1
@@ -64,7 +64,7 @@ void fsnotify_destroy_event(struct fsnotify_group *group,WARN_ON (!list_empty (&event->list));spin_unlock (&group->notification_lock); } - group->ops->free_event (event); + group->ops->free_event (group, event); }/*
include/linux/fsnotify_backend.h +1 -1
@@ -156,7 +156,7 @@ struct fsnotify_ops { const struct qstr *file_name, u32 cookie);void (*free_group_priv)(struct fsnotify_group *group);void (*freeing_mark)(struct fsnotify_mark *mark,struct fsnotify_group *group); -void (*free_event)(struct fsnotify_event *event); +void (*free_event)(struct fsnotify_group *group,struct fsnotify_event *event);/* called on final put+free to free memory */ void (*free_mark)(struct fsnotify_mark *mark); };
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 178/690 fanotify: Support null inode event in fanotify_dfid_inode
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 12f47bf0f0990933d95d021d13d31bda010648fd ]
FAN_FS_ERROR doesn't support DFID, but this function is still called for every event. The problem is that it is not capable of handling null inodes, which now can happen in case of superblock error events. For this case, just returning dir will be enough.
--- fs/notify/fanotify/fanotify.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +1 -1
@@ -452,7 +452,7 @@ static struct inode *fanotify_dfid_inode(u32 event_mask, const void *data,if (event_mask &ALL_FSNOTIFY_DIRENT_EVENTS )return dir; -if (S_ISDIR (inode->i_mode)) +if (inode &&S_ISDIR (inode->i_mode))return inode;return dir;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 179/690 fanotify: Allow file handle encoding for unhashed events
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 74fe4734897a2da2ae2a665a5e622cd490d36eaf ]
Allow passing a NULL hash to fanotify_encode_fh and avoid calculating the hash if not needed.
--- fs/notify/fanotify/fanotify.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
fs/notify/fanotify/fanotify.c +6 -2
@@ -403,8 +403,12 @@ static int fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type = type; fh->len = fh_len; -/* Mix fh into event merge key */ - *hash ^=fanotify_hash_fh (fh); +/* +* Mix fh into event merge key. Hash might be NULL in case of +* unhashed FID events (i.e. FAN_FS_ERROR). +*/ +if (hash) + *hash ^=fanotify_hash_fh (fh);return FANOTIFY_FH_HDR_LEN + fh_len;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 180/690 fanotify: Encode empty file handle when no inode is provided
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 272531ac619b374ab474e989eb387162fded553f ]
Instead of failing, encode an invalid file handle in fanotify_encode_fh if no inode is provided. This bogus file handle will be reported by FAN_FS_ERROR for non-inode errors.
--- fs/notify/fanotify/fanotify.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +8 -1
@@ -370,8 +370,14 @@ static int fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type =FILEID_ROOT ; fh->len =0 ; fh->flags =0 ; + +/* +* Invalid FHs are used by FAN_FS_ERROR for errors not +* linked to any inode. The f_handle won't be reported +* back to userspace. +*/ if (!inode) -return 0 ; + goto out;/* * !gpf means preallocated variable size fh, but fh_len could
@@ -403,6 +409,7 @@ static int fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type = type; fh->len = fh_len; +out:/* * Mix fh into event merge key. Hash might be NULL in case of * unhashed FID events (i.e. FAN_FS_ERROR).
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 181/690 fanotify: Require fid_mode for any non-fd event
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 4fe595cf1c80e7a5af4d00c4da29def64aff57a2 ]
Like inode events, FAN_FS_ERROR will require fid mode. Therefore, convert the verification during fanotify_mark(2) to require fid for any non-fd event. This means fid_mode will not only be required for inode events, but for any event that doesn't provide a descriptor.
--- fs/notify/fanotify/fanotify_user.c | 12 ++++++------ include/linux/fanotify.h | 3 +++ 2 files changed, 9 insertions(+), 6 deletions(-)
fs/notify/fanotify/fanotify_user.c +6 -6
@@ -1476,14 +1476,14 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, goto fput_and_out;/* -* Events with data type inode do not carry enough information to report -* event->fd, so we do not allow setting a mask for inode events unless -* group supports reporting fid. -* inode events are not supported on a mount mark, because they do not -* carry enough information (i.e. path) to be filtered by mount point. +* Events that do not carry enough information to report +* event->fd require a group that supports reporting fid. Those +* events are not supported on a mount mark, because they do not +* carry enough information (i.e. path) to be filtered by mount +* point. */ fid_mode =FAN_GROUP_FLAG (group,FANOTIFY_FID_BITS ); -if (mask &FANOTIFY_INODE_EVENTS && +if (mask & ~(FANOTIFY_FD_EVENTS |FANOTIFY_EVENT_FLAGS ) && (!fid_mode || mark_type ==FAN_MARK_MOUNT )) goto fput_and_out;
include/linux/fanotify.h +3 -0
@@ -84,6 +84,9 @@ extern struct ctl_table fanotify_table[]; /* for sysctl */*/ #define FANOTIFY_DIRENT_EVENTS (FAN_MOVE | FAN_CREATE | FAN_DELETE) +/* Events that can be reported with event->fd */ +#define FANOTIFY_FD_EVENTS (FANOTIFY_PATH_EVENTS | FANOTIFY_PERM_EVENTS) +/* Events that can only be reported with data type FSNOTIFY_EVENT_INODE */ #define FANOTIFY_INODE_EVENTS (FANOTIFY_DIRENT_EVENTS | \ FAN_ATTRIB | FAN_MOVE_SELF | FAN_DELETE_SELF)
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 182/690 fsnotify: Support FS_ERROR event type
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 9daa811073fa19c08e8aad3b90f9235fed161acf ]
Expose a new type of fsnotify event for filesystems to report errors for userspace monitoring tools. fanotify will send this type of notification for FAN_FS_ERROR events. This also introduce a helper for generating the new event.
--- include/linux/fsnotify.h | 13 +++++++++++++ include/linux/fsnotify_backend.h | 32 +++++++++++++++++++++++++++++++- 2 files changed, 44 insertions(+), 1 deletion(-)
include/linux/fsnotify.h +13 -0
@@ -375,4 +375,17 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid) fsnotify_dentry(dentry, mask); } +static inline int fsnotify_sb_error (struct super_block *sb,struct inode *inode, +int error) +{ +struct fs_error_report report = { + .error = error, + .inode = inode, + .sb = sb, + }; + +return fsnotify (FS_ERROR , &report,FSNOTIFY_EVENT_ERROR , +NULL ,NULL ,NULL ,0 ); +} +#endif /* _LINUX_FS_NOTIFY_H */
include/linux/fsnotify_backend.h +31 -1
@@ -42,6 +42,12 @@#define FS_UNMOUNT 0x00002000/* inode on umount fs */ #define FS_Q_OVERFLOW 0x00004000/* Event queued overflowed */ +#define FS_ERROR 0x00008000/* Filesystem Error (fanotify) */ + +/* +* FS_IN_IGNORED overloads FS_ERROR. It is only used internally by inotify +* which does not support FS_ERROR. +*/ #define FS_IN_IGNORED 0x00008000/* last inotify event here */ #define FS_OPEN_PERM 0x00010000/* open event in an permission hook */
@@ -95,7 +101,8 @@#define ALL_FSNOTIFY_EVENTS (ALL_FSNOTIFY_DIRENT_EVENTS | \ FS_EVENTS_POSS_ON_CHILD | \ FS_DELETE_SELF | FS_MOVE_SELF | FS_DN_RENAME | \ - FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED) + FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED | \ + FS_ERROR)/* Extra flags that may be reported with event or control handling of events */ #define ALL_FSNOTIFY_FLAGS (FS_EXCL_UNLINK | FS_ISDIR | FS_IN_ONESHOT | \
@@ -250,6 +257,13 @@ enum fsnotify_data_type {FSNOTIFY_EVENT_PATH ,FSNOTIFY_EVENT_INODE ,FSNOTIFY_EVENT_DENTRY , + FSNOTIFY_EVENT_ERROR, +}; + +struct fs_error_report { +int error; +struct inode *inode; +struct super_block *sb; };static inline struct inode *fsnotify_data_inode (const void *data,int data_type)
@@ -261,6 +275,8 @@ static inline struct inode *fsnotify_data_inode(const void *data, int data_type)return d_inode (data);case FSNOTIFY_EVENT_PATH :return d_inode (((const struct path *)data)->dentry); +case FSNOTIFY_EVENT_ERROR : +return ((struct fs_error_report *)data)->inode;default :return NULL ; }
@@ -300,6 +316,20 @@ static inline struct super_block *fsnotify_data_sb(const void *data,return ((struct dentry *)data)->d_sb;case FSNOTIFY_EVENT_PATH :return ((const struct path *)data)->dentry->d_sb; +case FSNOTIFY_EVENT_ERROR : +return ((struct fs_error_report *) data)->sb; +default : +return NULL ; + } +} + +static inline struct fs_error_report *fsnotify_data_error_report ( +const void *data, +int data_type) +{ +switch (data_type) { +case FSNOTIFY_EVENT_ERROR : +return (struct fs_error_report *) data;default :return NULL ; }
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 183/690 fanotify: Reserve UAPI bits for FAN_FS_ERROR
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 8d11a4f43ef4679be0908026907a7613b33d7127 ]
FAN_FS_ERROR allows reporting of event type FS_ERROR to userspace, which is a mechanism to report file system wide problems via fanotify. This commit preallocate userspace visible bits to match the FS_ERROR event.
--- fs/notify/fanotify/fanotify.c | 1 + include/uapi/linux/fanotify.h | 1 + 2 files changed, 2 insertions(+)
fs/notify/fanotify/fanotify.c +1 -0
@@ -752,6 +752,7 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask,BUILD_BUG_ON (FAN_ONDIR !=FS_ISDIR );BUILD_BUG_ON (FAN_OPEN_EXEC !=FS_OPEN_EXEC );BUILD_BUG_ON (FAN_OPEN_EXEC_PERM !=FS_OPEN_EXEC_PERM ); +BUILD_BUG_ON (FAN_FS_ERROR !=FS_ERROR );BUILD_BUG_ON (HWEIGHT32 (ALL_FANOTIFY_EVENT_BITS ) !=19 );
include/uapi/linux/fanotify.h +1 -0
@@ -20,6 +20,7 @@#define FAN_OPEN_EXEC 0x00001000/* File was opened for exec */ #define FAN_Q_OVERFLOW 0x00004000/* Event queued overflowed */ +#define FAN_FS_ERROR 0x00008000/* Filesystem error */ #define FAN_OPEN_PERM 0x00010000/* File open in perm check */ #define FAN_ACCESS_PERM 0x00020000/* File accessed in perm check */
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 184/690 fanotify: Pre-allocate pool of error events
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 734a1a5eccc5f7473002b0669f788e135f1f64aa ]
Pre-allocate slots for file system errors to have greater chances of succeeding, since error events can happen in GFP_NOFS context. This patch introduces a group-wide mempool of error events, shared by all FAN_FS_ERROR marks in this group.
--- fs/notify/fanotify/fanotify.c | 3 +++ fs/notify/fanotify/fanotify.h | 11 +++++++++++ fs/notify/fanotify/fanotify_user.c | 26 +++++++++++++++++++++++++- include/linux/fsnotify_backend.h | 2 ++ 4 files changed, 41 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +3 -0
@@ -819,6 +819,9 @@ static void fanotify_free_group_priv(struct fsnotify_group *group)if (group->fanotify_data.ucounts)dec_ucount (group->fanotify_data.ucounts,UCOUNT_FANOTIFY_GROUPS ); + +if (mempool_initialized (&group->fanotify_data.error_events_pool)) +mempool_exit (&group->fanotify_data.error_events_pool); }static void fanotify_free_path_event (struct fanotify_event *event)
fs/notify/fanotify/fanotify.h +11 -0
@@ -141,6 +141,7 @@ enum fanotify_event_type {FANOTIFY_EVENT_TYPE_PATH ,FANOTIFY_EVENT_TYPE_PATH_PERM ,FANOTIFY_EVENT_TYPE_OVERFLOW ,/* struct fanotify_event */ +FANOTIFY_EVENT_TYPE_FS_ERROR ,/* struct fanotify_error_event */ __FANOTIFY_EVENT_TYPE_NUM };
@@ -196,6 +197,16 @@ FANOTIFY_NE(struct fanotify_event *event) return container_of(event, struct fanotify_name_event, fae); } +struct fanotify_error_event { +struct fanotify_event fae; +}; + +static inline struct fanotify_error_event * +FANOTIFY_EE (struct fanotify_event *event) +{ + return container_of(event, struct fanotify_error_event, fae); +} +static inline __kernel_fsid_t *fanotify_event_fsid (struct fanotify_event *event) {if (event->type ==FANOTIFY_EVENT_TYPE_FID )
fs/notify/fanotify/fanotify_user.c +25 -1
@@ -30,6 +30,7 @@#define FANOTIFY_DEFAULT_MAX_EVENTS 16384#define FANOTIFY_OLD_DEFAULT_MAX_MARKS 8192#define FANOTIFY_DEFAULT_MAX_GROUPS 128 +#define FANOTIFY_DEFAULT_FEE_POOL_SIZE 32/* * Legacy fanotify marks limits (8192) is per group and we introduced a tunable
@@ -1054,6 +1055,15 @@ static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,return ERR_PTR (ret); } +static int fanotify_group_init_error_pool (struct fsnotify_group *group) +{ +if (mempool_initialized (&group->fanotify_data.error_events_pool)) +return 0 ; + +return mempool_init_kmalloc_pool (&group->fanotify_data.error_events_pool, +FANOTIFY_DEFAULT_FEE_POOL_SIZE , +sizeof (struct fanotify_error_event )); +} static int fanotify_add_mark(struct fsnotify_group *group, fsnotify_connp_t *connp, unsigned int type,
@@ -1062,6 +1072,7 @@ static int fanotify_add_mark(struct fsnotify_group *group, {struct fsnotify_mark *fsn_mark;__u32 added; +int ret =0 ;mutex_lock (&group->mark_mutex); fsn_mark =fsnotify_find_mark (connp, group);
@@ -1072,13 +1083,26 @@ static int fanotify_add_mark(struct fsnotify_group *group,return PTR_ERR (fsn_mark); } } + +/* +* Error events are pre-allocated per group, only if strictly +* needed (i.e. FAN_FS_ERROR was requested). +*/ +if (!(flags &FAN_MARK_IGNORED_MASK ) && (mask &FAN_FS_ERROR )) { + ret =fanotify_group_init_error_pool (group); +if (ret) + goto out; + } + added =fanotify_mark_add_to_mask (fsn_mark, mask, flags);if (added & ~fsnotify_conn_mask (fsn_mark->connector))fsnotify_recalc_mask (fsn_mark->connector); + +out:mutex_unlock (&group->mark_mutex);fsnotify_put_mark (fsn_mark); -return 0 ; +return ret; } static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
include/linux/fsnotify_backend.h +2 -0
@@ -19,6 +19,7 @@#include <linux/atomic.h> #include <linux/user_namespace.h> #include <linux/refcount.h> +#include <linux/mempool.h> /* * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
@@ -246,6 +247,7 @@ struct fsnotify_group {int flags;/* flags from fanotify_init() */ int f_flags;/* event_f_flags from fanotify_init() */ struct ucounts *ucounts; + mempool_t error_events_pool; } fanotify_data;#endif /* CONFIG_FANOTIFY */ };
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 185/690 fanotify: Support enqueueing of error events
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 83e9acbe13dc1b767f91b5c1350f7a65689b26f6 ]
Once an error event is triggered, enqueue it in the notification group, similarly to what is done for other events. FAN_FS_ERROR is not handled specially, since the memory is now handled by a preallocated mempool.
For now, make the event unhashed. A future patch implements merging of this kind of event.
--- fs/notify/fanotify/fanotify.c | 35 +++++++++++++++++++++++++++++++++++ fs/notify/fanotify/fanotify.h | 6 ++++++ 2 files changed, 41 insertions(+)
fs/notify/fanotify/fanotify.c +35 -0
@@ -574,6 +574,27 @@ static struct fanotify_event *fanotify_alloc_name_event(struct inode *id,return &fne->fae; } +static struct fanotify_event *fanotify_alloc_error_event ( +struct fsnotify_group *group, +__kernel_fsid_t *fsid, +const void *data,int data_type) +{ +struct fs_error_report *report = +fsnotify_data_error_report (data, data_type); +struct fanotify_error_event *fee; + +if (WARN_ON_ONCE (!report)) +return NULL ; + + fee =mempool_alloc (&group->fanotify_data.error_events_pool,GFP_NOFS ); +if (!fee) +return NULL ; + + fee->fae.type =FANOTIFY_EVENT_TYPE_FS_ERROR ; + +return &fee->fae; +} + static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group, u32 mask, const void *data, int data_type, struct inode *dir,
@@ -641,6 +662,9 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,if (fanotify_is_perm_event (mask)) { event =fanotify_alloc_perm_event (path, gfp); + }else if (fanotify_is_error_event (mask)) { + event =fanotify_alloc_error_event (group, fsid, data, + data_type); }else if (name_event && (file_name || child)) { event =fanotify_alloc_name_event (id, fsid, file_name, child, &hash, gfp);
@@ -850,6 +874,14 @@ static void fanotify_free_name_event(struct fanotify_event *event)kfree (FANOTIFY_NE (event)); } +static void fanotify_free_error_event (struct fsnotify_group *group, +struct fanotify_event *event) +{ +struct fanotify_error_event *fee =FANOTIFY_EE (event); + +mempool_free (fee, &group->fanotify_data.error_events_pool); +} +static void fanotify_free_event (struct fsnotify_group *group,struct fsnotify_event *fsn_event) {
@@ -873,6 +905,9 @@ static void fanotify_free_event(struct fsnotify_group *group,case FANOTIFY_EVENT_TYPE_OVERFLOW :kfree (event);break ; +case FANOTIFY_EVENT_TYPE_FS_ERROR : +fanotify_free_error_event (group, event); +break ;default :WARN_ON_ONCE (1 ); }
fs/notify/fanotify/fanotify.h +6 -0
@@ -298,6 +298,11 @@ static inline struct fanotify_event *FANOTIFY_E(struct fsnotify_event *fse) return container_of(fse, struct fanotify_event, fse); } +static inline bool fanotify_is_error_event (u32 mask) +{ +return mask &FAN_FS_ERROR ; +} +static inline bool fanotify_event_has_path (struct fanotify_event *event) { return event->type == FANOTIFY_EVENT_TYPE_PATH ||
@@ -327,6 +332,7 @@ static inline struct path *fanotify_event_path(struct fanotify_event *event)static inline bool fanotify_is_hashed_event (u32 mask) {return !(fanotify_is_perm_event (mask) || +fanotify_is_error_event (mask) ||fsnotify_is_overflow_event (mask)); }
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 186/690 fanotify: Support merging of error events
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 8a6ae64132fd27a944faed7bc38484827609eb76 ]
Error events (FAN_FS_ERROR) against the same file system can be merged by simply iterating the error count. The hash is taken from the fsid, without considering the FH. This means that only the first error object is reported.
--- fs/notify/fanotify/fanotify.c | 26 ++++++++++++++++++++++++-- fs/notify/fanotify/fanotify.h | 4 +++- 2 files changed, 27 insertions(+), 3 deletions(-)
fs/notify/fanotify/fanotify.c +24 -2
@@ -111,6 +111,16 @@ static bool fanotify_name_event_equal(struct fanotify_name_event *fne1,return fanotify_info_equal (info1, info2); } +static bool fanotify_error_event_equal (struct fanotify_error_event *fee1, +struct fanotify_error_event *fee2) +{ +/* Error events against the same file system are always merged. */ +if (!fanotify_fsid_equal (&fee1->fsid, &fee2->fsid)) +return false; + +return true; +} +static bool fanotify_should_merge (struct fanotify_event *old,struct fanotify_event *new) {
@@ -141,6 +151,9 @@ static bool fanotify_should_merge(struct fanotify_event *old,case FANOTIFY_EVENT_TYPE_FID_NAME :return fanotify_name_event_equal (FANOTIFY_NE (old),FANOTIFY_NE (new)); +case FANOTIFY_EVENT_TYPE_FS_ERROR : +return fanotify_error_event_equal (FANOTIFY_EE (old), +FANOTIFY_EE (new));default :WARN_ON_ONCE (1 ); }
@@ -176,6 +189,10 @@ static int fanotify_merge(struct fsnotify_group *group,break ;if (fanotify_should_merge (old, new)) { old->mask |= new->mask; + +if (fanotify_is_error_event (old->mask)) +FANOTIFY_EE (old)->err_count++; +return 1 ; } }
@@ -577,7 +594,8 @@ static struct fanotify_event *fanotify_alloc_name_event(struct inode *id,static struct fanotify_event *fanotify_alloc_error_event (struct fsnotify_group *group,__kernel_fsid_t *fsid, -const void *data,int data_type) +const void *data,int data_type, +unsigned int *hash) {struct fs_error_report *report =fsnotify_data_error_report (data, data_type);
@@ -591,6 +609,10 @@ static struct fanotify_event *fanotify_alloc_error_event(return NULL ; fee->fae.type =FANOTIFY_EVENT_TYPE_FS_ERROR ; + fee->err_count =1 ; + fee->fsid = *fsid; + + *hash ^=fanotify_hash_fsid (fsid);return &fee->fae; }
@@ -664,7 +686,7 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group, event =fanotify_alloc_perm_event (path, gfp); }else if (fanotify_is_error_event (mask)) { event =fanotify_alloc_error_event (group, fsid, data, - data_type); + data_type, &hash); }else if (name_event && (file_name || child)) { event =fanotify_alloc_name_event (id, fsid, file_name, child, &hash, gfp);
fs/notify/fanotify/fanotify.h +3 -1
@@ -199,6 +199,9 @@ FANOTIFY_NE(struct fanotify_event *event)struct fanotify_error_event {struct fanotify_event fae; +u32 err_count;/* Suppressed errors count */ + +__kernel_fsid_t fsid;/* FSID this error refers to. */ }; static inline struct fanotify_error_event *
@@ -332,7 +335,6 @@ static inline struct path *fanotify_event_path(struct fanotify_event *event)static inline bool fanotify_is_hashed_event (u32 mask) {return !(fanotify_is_perm_event (mask) || -fanotify_is_error_event (mask) ||fsnotify_is_overflow_event (mask)); }
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 187/690 fanotify: Wrap object_fh inline space in a creator macro
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 2c5069433a3adc01ff9c5673567961bb7f138074 ]
fanotify_error_event would duplicate this sequence of declarations that already exist elsewhere with a slight different size. Create a helper macro to avoid code duplication.
--- fs/notify/fanotify/fanotify.h | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
fs/notify/fanotify/fanotify.h +9 -3
@@ -171,12 +171,18 @@ static inline void fanotify_init_event(struct fanotify_event *event, event->pid =NULL ; } +#define FANOTIFY_INLINE_FH (name, size) \ +struct { \ + struct fanotify_fh (name); \ +/* Space for object_fh.buf[] - access with fanotify_fh_buf() */ \ +unsigned char _inline_fh_buf[(size)]; \ +} +struct fanotify_fid_event {struct fanotify_event fae;__kernel_fsid_t fsid; -struct fanotify_fh object_fh; -/* Reserve space in object_fh.buf[] - access with fanotify_fh_buf() */ -unsigned char _inline_fh_buf[FANOTIFY_INLINE_FH_LEN ]; + + FANOTIFY_INLINE_FH(object_fh, FANOTIFY_INLINE_FH_LEN); }; static inline struct fanotify_fid_event *
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 188/690 fanotify: Add helpers to decide whether to report FID/DFID
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 4bd5a5c8e6e5cd964e9738e6ef87f6c2cb453edf ]
Now that there is an event that reports FID records even for a zeroed file handle, wrap the logic that deides whether to issue the records into helper functions. This shouldn't have any impact on the code, but simplifies further patches.
--- fs/notify/fanotify/fanotify.h | 10 ++++++++++ fs/notify/fanotify/fanotify_user.c | 13 +++++++------ 2 files changed, 17 insertions(+), 6 deletions(-)
fs/notify/fanotify/fanotify.h +10 -0
@@ -264,6 +264,16 @@ static inline int fanotify_event_dir_fh_len(struct fanotify_event *event)return info ?fanotify_info_dir_fh_len (info) :0 ; } +static inline bool fanotify_event_has_object_fh (struct fanotify_event *event) +{ +return fanotify_event_object_fh_len (event) >0 ; +} + +static inline bool fanotify_event_has_dir_fh (struct fanotify_event *event) +{ +return fanotify_event_dir_fh_len (event) >0 ; +} +struct fanotify_path_event {struct fanotify_event fae;struct path path;
fs/notify/fanotify/fanotify_user.c +7 -6
@@ -140,10 +140,9 @@ static size_t fanotify_event_len(unsigned int info_mode,return event_len; info =fanotify_event_info (event); - dir_fh_len =fanotify_event_dir_fh_len (event); - fh_len =fanotify_event_object_fh_len (event); -if (dir_fh_len) { +if (fanotify_event_has_dir_fh (event)) { + dir_fh_len =fanotify_event_dir_fh_len (event); event_len +=fanotify_fid_info_len (dir_fh_len, info->name_len); }else if ((info_mode &FAN_REPORT_NAME ) && (event->mask &FAN_ONDIR )) {
@@ -157,8 +156,10 @@ static size_t fanotify_event_len(unsigned int info_mode,if (info_mode &FAN_REPORT_PIDFD ) event_len +=FANOTIFY_PIDFD_INFO_HDR_LEN ; -if (fh_len) +if (fanotify_event_has_object_fh (event)) { + fh_len =fanotify_event_object_fh_len (event); event_len +=fanotify_fid_info_len (fh_len, dot_len); + }return event_len; }
@@ -451,7 +452,7 @@ static int copy_info_records_to_user(struct fanotify_event *event,/* * Event info records order is as follows: dir fid + name, child fid. */ -if (fanotify_event_dir_fh_len (event)) { +if (fanotify_event_has_dir_fh (event)) { info_type = info->name_len ?FAN_EVENT_INFO_TYPE_DFID_NAME :FAN_EVENT_INFO_TYPE_DFID ; ret = copy_fid_info_to_user(fanotify_event_fsid(event),
@@ -467,7 +468,7 @@ static int copy_info_records_to_user(struct fanotify_event *event, total_bytes += ret; } -if (fanotify_event_object_fh_len (event)) { +if (fanotify_event_has_object_fh (event)) {const char *dot =NULL ;int dot_len =0 ;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 189/690 fanotify: WARN_ON against too large file handles
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 572c28f27a269f88e2d8d7b6b1507f114d637337 ]
struct fanotify_error_event, at least, is preallocated and isn't able to to handle arbitrarily large file handles. Future-proof the code by complaining loudly if a handle larger than MAX_HANDLE_SZ is ever found.
--- fs/notify/fanotify/fanotify.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +11 -1
@@ -360,13 +360,23 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,static int fanotify_encode_fh_len (struct inode *inode) {int dwords =0 ; +int fh_len;if (!inode)return 0 ;exportfs_encode_inode_fh (inode,NULL , &dwords,NULL ); + fh_len = dwords <<2 ; -return dwords <<2 ; +/* +* struct fanotify_error_event might be preallocated and is +* limited to MAX_HANDLE_SZ. This should never happen, but +* safeguard by forcing an invalid file handle. +*/ +if (WARN_ON_ONCE (fh_len >MAX_HANDLE_SZ )) +return 0 ; + +return fh_len; }/*
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 190/690 fanotify: Report fid info for file related file system errors
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 936d6a38be39177495af38497bf8da1c6128fa1b ]
Plumb the pieces to add a FID report to error records. Since all error event memory must be pre-allocated, we pre-allocate the maximum file handle size possible, such that it should always fit.
For errors that don't expose a file handle, report it with an invalid FID. Internally we use zero-length FILEID_ROOT file handle for passing the information (which we report as zero-length FILEID_INVALID file handle to userspace) so we update the handle reporting code to deal with this case correctly.
--- fs/notify/fanotify/fanotify.c | 11 +++++++++++ fs/notify/fanotify/fanotify.h | 9 +++++++++ fs/notify/fanotify/fanotify_user.c | 8 +++++--- 3 files changed, 25 insertions(+), 3 deletions(-)
fs/notify/fanotify/fanotify.c +11 -0
@@ -609,7 +609,9 @@ static struct fanotify_event *fanotify_alloc_error_event( {struct fs_error_report *report =fsnotify_data_error_report (data, data_type); +struct inode *inode;struct fanotify_error_event *fee; +int fh_len;if (WARN_ON_ONCE (!report))return NULL ;
@@ -622,6 +624,15 @@ static struct fanotify_event *fanotify_alloc_error_event( fee->err_count =1 ; fee->fsid = *fsid; + inode = report->inode; + fh_len =fanotify_encode_fh_len (inode); + +/* Bad fh_len. Fallback to using an invalid fh. Should never happen. */ +if (!fh_len && inode) + inode =NULL ; + +fanotify_encode_fh (&fee->object_fh, inode, fh_len,NULL ,0 ); + *hash ^=fanotify_hash_fsid (fsid);return &fee->fae;
fs/notify/fanotify/fanotify.h +9 -0
@@ -208,6 +208,8 @@ struct fanotify_error_event {u32 err_count;/* Suppressed errors count */ __kernel_fsid_t fsid;/* FSID this error refers to. */ + +FANOTIFY_INLINE_FH (object_fh,MAX_HANDLE_SZ ); }; static inline struct fanotify_error_event *
@@ -222,6 +224,8 @@ static inline __kernel_fsid_t *fanotify_event_fsid(struct fanotify_event *event)return &FANOTIFY_FE (event)->fsid; else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME) return &FANOTIFY_NE(event)->fsid; + else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR) + return &FANOTIFY_EE(event)->fsid; else return NULL; }
@@ -233,6 +237,8 @@ static inline struct fanotify_fh *fanotify_event_object_fh(return &FANOTIFY_FE (event)->object_fh; else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME) return fanotify_info_file_fh(&FANOTIFY_NE(event)->info); + else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR) + return &FANOTIFY_EE(event)->object_fh; else return NULL; }
@@ -266,6 +272,9 @@ static inline int fanotify_event_dir_fh_len(struct fanotify_event *event)static inline bool fanotify_event_has_object_fh (struct fanotify_event *event) { +/* For error events, even zeroed fh are reported. */ +if (event->type ==FANOTIFY_EVENT_TYPE_FS_ERROR ) +return true;return fanotify_event_object_fh_len (event) >0 ; }
fs/notify/fanotify/fanotify_user.c +5 -3
@@ -339,9 +339,6 @@ static int copy_fid_info_to_user(__kernel_fsid_t *fsid, struct fanotify_fh *fh,pr_debug ("%s: fh_len=%zu name_len=%zu, info_len=%zu, count=%zu\n" , __func__, fh_len, name_len, info_len, count); -if (!fh_len) -return 0 ; -if (WARN_ON_ONCE (len <sizeof (info) || len > count))return -EFAULT ;
@@ -376,6 +373,11 @@ static int copy_fid_info_to_user(__kernel_fsid_t *fsid, struct fanotify_fh *fh, handle.handle_type = fh->type; handle.handle_bytes = fh_len; + +/* Mangle handle_type for bad file_handle */ +if (!fh_len) + handle.handle_type =FILEID_INVALID ; +if (copy_to_user (buf, &handle,sizeof (handle)))return -EFAULT ;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 191/690 fanotify: Emit generic error info for error event
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 130a3c742107acff985541c28360c8b40203559c ]
The error info is a record sent to users on FAN_FS_ERROR events documenting the type of error. It also carries an error count, documenting how many errors were observed since the last reporting.
--- fs/notify/fanotify/fanotify.c | 1 + fs/notify/fanotify/fanotify.h | 1 + fs/notify/fanotify/fanotify_user.c | 36 ++++++++++++++++++++++++++++++ include/uapi/linux/fanotify.h | 7 ++++++ 4 files changed, 45 insertions(+)
fs/notify/fanotify/fanotify.c +1 -0
@@ -621,6 +621,7 @@ static struct fanotify_event *fanotify_alloc_error_event(return NULL ; fee->fae.type =FANOTIFY_EVENT_TYPE_FS_ERROR ; + fee->error = report->error; fee->err_count =1 ; fee->fsid = *fsid;
fs/notify/fanotify/fanotify.h +1 -0
@@ -205,6 +205,7 @@ FANOTIFY_NE(struct fanotify_event *event)struct fanotify_error_event {struct fanotify_event fae; +s32 error;/* Error reported by the Filesystem. */ u32 err_count;/* Suppressed errors count */ __kernel_fsid_t fsid;/* FSID this error refers to. */
fs/notify/fanotify/fanotify_user.c +36 -0
@@ -115,6 +115,8 @@ struct kmem_cache *fanotify_perm_event_cachep __read_mostly; (sizeof(struct fanotify_event_info_fid) + sizeof(struct file_handle))#define FANOTIFY_PIDFD_INFO_HDR_LEN \ sizeof(struct fanotify_event_info_pidfd) +#define FANOTIFY_ERROR_INFO_LEN \ + (sizeof(struct fanotify_event_info_error))static int fanotify_fid_info_len (int fh_len,int name_len) {
@@ -139,6 +141,9 @@ static size_t fanotify_event_len(unsigned int info_mode,if (!info_mode)return event_len; +if (fanotify_is_error_event (event->mask)) + event_len +=FANOTIFY_ERROR_INFO_LEN ; + info =fanotify_event_info (event);if (fanotify_event_has_dir_fh (event)) {
@@ -324,6 +329,28 @@ static int process_access_response(struct fsnotify_group *group,return -ENOENT ; } +static size_t copy_error_info_to_user (struct fanotify_event *event, +char __user *buf,int count) +{ +struct fanotify_event_info_error info; +struct fanotify_error_event *fee =FANOTIFY_EE (event); + + info.hdr.info_type =FAN_EVENT_INFO_TYPE_ERROR ; + info.hdr.pad =0 ; + info.hdr.len =FANOTIFY_ERROR_INFO_LEN ; + +if (WARN_ON (count < info.hdr.len)) +return -EFAULT ; + + info.error = fee->error; + info.error_count = fee->err_count; + +if (copy_to_user (buf, &info,sizeof (info))) +return -EFAULT ; + +return info.hdr.len; +} + static int copy_fid_info_to_user(__kernel_fsid_t *fsid, struct fanotify_fh *fh, int info_type, const char *name, size_t name_len,
@@ -530,6 +557,15 @@ static int copy_info_records_to_user(struct fanotify_event *event, total_bytes += ret; } +if (fanotify_is_error_event (event->mask)) { + ret =copy_error_info_to_user (event, buf, count); +if (ret <0 ) +return ret; + buf += ret; + count -= ret; + total_bytes += ret; + } +return total_bytes; }
include/uapi/linux/fanotify.h +7 -0
@@ -126,6 +126,7 @@ struct fanotify_event_metadata {#define FAN_EVENT_INFO_TYPE_DFID_NAME 2#define FAN_EVENT_INFO_TYPE_DFID 3#define FAN_EVENT_INFO_TYPE_PIDFD 4 +#define FAN_EVENT_INFO_TYPE_ERROR 5/* Variable length info record following event metadata */ struct fanotify_event_info_header {
@@ -160,6 +161,12 @@ struct fanotify_event_info_pidfd {__s32 pidfd; }; +struct fanotify_event_info_error { +struct fanotify_event_info_header hdr; +__s32 error; +__u32 error_count; +}; +struct fanotify_response {__s32 fd;__u32 response;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 192/690 fanotify: Allow users to request FAN_FS_ERROR events
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 9709bd548f11a092d124698118013f66e1740f9b ]
Wire up the FAN_FS_ERROR event in the fanotify_mark syscall, allowing user space to request the monitoring of FAN_FS_ERROR events.
These events are limited to filesystem marks, so check it is the case in the syscall handler.
--- fs/notify/fanotify/fanotify.c | 2 +- fs/notify/fanotify/fanotify_user.c | 4 ++++ include/linux/fanotify.h | 6 +++++- 3 files changed, 10 insertions(+), 2 deletions(-)
fs/notify/fanotify/fanotify.c +1 -1
@@ -822,7 +822,7 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask,BUILD_BUG_ON (FAN_OPEN_EXEC_PERM !=FS_OPEN_EXEC_PERM );BUILD_BUG_ON (FAN_FS_ERROR !=FS_ERROR ); -BUILD_BUG_ON (HWEIGHT32 (ALL_FANOTIFY_EVENT_BITS ) !=19 ); +BUILD_BUG_ON (HWEIGHT32 (ALL_FANOTIFY_EVENT_BITS ) !=20 ); mask =fanotify_group_event_mask (group, iter_info, mask, data, data_type, dir);
fs/notify/fanotify/fanotify_user.c +4 -0
@@ -1538,6 +1538,10 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, group->priority == FS_PRIO_0) goto fput_and_out; +if (mask &FAN_FS_ERROR && + mark_type !=FAN_MARK_FILESYSTEM ) + goto fput_and_out; +/* * Events that do not carry enough information to report * event->fd require a group that supports reporting fid. Those
include/linux/fanotify.h +5 -1
@@ -91,9 +91,13 @@ extern struct ctl_table fanotify_table[]; /* for sysctl */#define FANOTIFY_INODE_EVENTS (FANOTIFY_DIRENT_EVENTS | \ FAN_ATTRIB | FAN_MOVE_SELF | FAN_DELETE_SELF) +/* Events that can only be reported with data type FSNOTIFY_EVENT_ERROR */ +#define FANOTIFY_ERROR_EVENTS (FAN_FS_ERROR) +/* Events that user can request to be notified on */ #define FANOTIFY_EVENTS (FANOTIFY_PATH_EVENTS | \ - FANOTIFY_INODE_EVENTS) + FANOTIFY_INODE_EVENTS | \ + FANOTIFY_ERROR_EVENTS)/* Events that require a permission response from user */ #define FANOTIFY_PERM_EVENTS (FAN_OPEN_PERM | FAN_ACCESS_PERM | \
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 193/690 ext4: Send notifications on error
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 9a089b21f79b47eed240d4da7ea0d049de7c9b4d ]
Send a FS_ERROR message via fsnotify to a userspace monitoring tool whenever a ext4 error condition is triggered. This follows the existing error conditions in ext4, so it is hooked to the ext4_error* functions.
--- fs/ext4/super.c | 8 ++++++++ 1 file changed, 8 insertions(+)
fs/ext4/super.c +8 -0
@@ -46,6 +46,7 @@#include <linux/part_stat.h> #include <linux/kthread.h> #include <linux/freezer.h> +#include <linux/fsnotify.h> #include "ext4.h" #include "ext4_extents.h" /* Needed for trace points definition */
@@ -753,6 +754,8 @@ void __ext4_error(struct super_block *sb, const char *function, sb->s_id, function, line, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (sb,NULL , error ? error :EFSCORRUPTED ); +ext4_handle_error (sb, force_ro, error,0 , block, function, line); }
@@ -783,6 +786,8 @@ void __ext4_error_inode(struct inode *inode, const char *function, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode, error ? error :EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false, error, inode->i_ino, block, function, line); }
@@ -821,6 +826,8 @@ void __ext4_error_file(struct file *file, const char *function, current->comm, path, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode,EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false,EFSCORRUPTED , inode->i_ino, block, function, line); }
@@ -888,6 +895,7 @@ void __ext4_std_error(struct super_block *sb, const char *function,printk (KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n" , sb->s_id, function, line, errstr); } +fsnotify_sb_error (sb,NULL , errno ? errno :EFSCORRUPTED );ext4_handle_error (sb, false, -errno,0 ,0 , function, line); }
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 194/690 docs: Document the FAN_FS_ERROR event
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit c0baf9ac0b05d53dfe0436661dbdc5e43c01c5e0 ]
Document the FAN_FS_ERROR event for user administrators and user space developers.
--- .../admin-guide/filesystem-monitoring.rst | 74 +++++++++++++++++++ Documentation/admin-guide/index.rst | 1 + 2 files changed, 75 insertions(+) create mode 100644 Documentation/admin-guide/filesystem-monitoring.rst
Documentation/admin-guide/filesystem-monitoring.rst new file +74 -0
@@ -0,0 +1,74 @@ +.. SPDX-License-Identifier: GPL-2.0 + +==================================== +File system Monitoring with fanotify +==================================== + +File system Error Reporting +=========================== + +Fanotify supports the FAN_FS_ERROR event type for file system-wide error +reporting. It is meant to be used by file system health monitoring +daemons, which listen for these events and take actions (notify +sysadmin, start recovery) when a file system problem is detected. + +By design, a FAN_FS_ERROR notification exposes sufficient information +for a monitoring tool to know a problem in the file system has happened. +It doesn't necessarily provide a user space application with semantics +to verify an IO operation was successfully executed. That is out of +scope for this feature. Instead, it is only meant as a framework for +early file system problem detection and reporting recovery tools. + +When a file system operation fails, it is common for dozens of kernel +errors to cascade after the initial failure, hiding the original failure +log, which is usually the most useful debug data to troubleshoot the +problem. For this reason, FAN_FS_ERROR tries to report only the first +error that occurred for a file system since the last notification, and +it simply counts additional errors. This ensures that the most +important pieces of information are never lost. + +FAN_FS_ERROR requires the fanotify group to be setup with the +FAN_REPORT_FID flag. + +At the time of this writing, the only file system that emits FAN_FS_ERROR +notifications is Ext4. + +A FAN_FS_ERROR Notification has the following format:: + + [ Notification Metadata (Mandatory) ] + [ Generic Error Record (Mandatory) ] + [ FID record (Mandatory) ] + +The order of records is not guaranteed, and new records might be added +in the future. Therefore, applications must not rely on the order and +must be prepared to skip over unknown records. Please refer to +``samples/fanotify/fs-monitor.c`` for an example parser. + +Generic error record +-------------------- + +The generic error record provides enough information for a file system +agnostic tool to learn about a problem in the file system, without +providing any additional details about the problem. This record is +identified by ``struct fanotify_event_info_header.info_type`` being set +to FAN_EVENT_INFO_TYPE_ERROR. + + struct fanotify_event_info_error { + struct fanotify_event_info_header hdr; + __s32 error; + __u32 error_count; + }; + +The `error` field identifies the type of error using errno values. +`error_count` tracks the number of errors that occurred and were +suppressed to preserve the original error information, since the last +notification. + +FID record +---------- + +The FID record can be used to uniquely identify the inode that triggered +the error through the combination of fsid and file handle. A file system +specific application can use that information to attempt a recovery +procedure. Errors that are not related to an inode are reported with an +empty file handle of type FILEID_INVALID.
Documentation/admin-guide/index.rst +1 -0
@@ -82,6 +82,7 @@ configure specific aspects of kernel behavior to your liking. edid efi-stub ext4 + filesystem-monitoring nfs/index gpio/index highuid
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 195/690 NFS: Remove unnecessary TRACE_DEFINE_ENUM()s
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit 8e09650f5ec68858f4b8b67cdef9e2ece9b208f3 ]
Clean up: TRACE_DEFINE_ENUM is unnecessary because the target symbols are all C macros, not enums.
--- fs/nfs/nfstrace.h | 68 ----------------------------------------------- 1 file changed, 68 deletions(-)
fs/nfs/nfstrace.h +0 -68
@@ -11,16 +11,6 @@#include <linux/tracepoint.h> #include <linux/iversion.h> -TRACE_DEFINE_ENUM (DT_UNKNOWN ); -TRACE_DEFINE_ENUM (DT_FIFO ); -TRACE_DEFINE_ENUM (DT_CHR ); -TRACE_DEFINE_ENUM (DT_DIR ); -TRACE_DEFINE_ENUM (DT_BLK ); -TRACE_DEFINE_ENUM (DT_REG ); -TRACE_DEFINE_ENUM (DT_LNK ); -TRACE_DEFINE_ENUM (DT_SOCK ); -TRACE_DEFINE_ENUM (DT_WHT ); -#define nfs_show_file_type (ftype) \ __print_symbolic(ftype, \ { DT_UNKNOWN, "UNKNOWN" }, \
@@ -33,24 +23,6 @@ TRACE_DEFINE_ENUM(DT_WHT); { DT_SOCK, "SOCK" }, \ { DT_WHT, "WHT" }) -TRACE_DEFINE_ENUM (NFS_INO_INVALID_DATA ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_ATIME ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_ACCESS ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_ACL ); -TRACE_DEFINE_ENUM (NFS_INO_REVAL_PAGECACHE ); -TRACE_DEFINE_ENUM (NFS_INO_REVAL_FORCED ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_LABEL ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_CHANGE ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_CTIME ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_MTIME ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_SIZE ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_OTHER ); -TRACE_DEFINE_ENUM (NFS_INO_DATA_INVAL_DEFER ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_BLOCKS ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_XATTR ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_NLINK ); -TRACE_DEFINE_ENUM (NFS_INO_INVALID_MODE ); -#define nfs_show_cache_validity (v) \ __print_flags(v, "|", \ { NFS_INO_INVALID_DATA, "INVALID_DATA" }, \
@@ -71,17 +43,6 @@ TRACE_DEFINE_ENUM(NFS_INO_INVALID_MODE); { NFS_INO_INVALID_NLINK, "INVALID_NLINK" }, \ { NFS_INO_INVALID_MODE, "INVALID_MODE" }) -TRACE_DEFINE_ENUM (NFS_INO_ADVISE_RDPLUS ); -TRACE_DEFINE_ENUM (NFS_INO_STALE ); -TRACE_DEFINE_ENUM (NFS_INO_ACL_LRU_SET ); -TRACE_DEFINE_ENUM (NFS_INO_INVALIDATING ); -TRACE_DEFINE_ENUM (NFS_INO_FSCACHE ); -TRACE_DEFINE_ENUM (NFS_INO_FSCACHE_LOCK ); -TRACE_DEFINE_ENUM (NFS_INO_LAYOUTCOMMIT ); -TRACE_DEFINE_ENUM (NFS_INO_LAYOUTCOMMITTING ); -TRACE_DEFINE_ENUM (NFS_INO_LAYOUTSTATS ); -TRACE_DEFINE_ENUM (NFS_INO_ODIRECT ); -#define nfs_show_nfsi_flags (v) \ __print_flags(v, "|", \ { BIT(NFS_INO_ADVISE_RDPLUS), "ADVISE_RDPLUS" }, \
@@ -270,19 +231,6 @@ TRACE_EVENT(nfs_access_exit, ) ); -TRACE_DEFINE_ENUM (LOOKUP_FOLLOW ); -TRACE_DEFINE_ENUM (LOOKUP_DIRECTORY ); -TRACE_DEFINE_ENUM (LOOKUP_AUTOMOUNT ); -TRACE_DEFINE_ENUM (LOOKUP_PARENT ); -TRACE_DEFINE_ENUM (LOOKUP_REVAL ); -TRACE_DEFINE_ENUM (LOOKUP_RCU ); -TRACE_DEFINE_ENUM (LOOKUP_OPEN ); -TRACE_DEFINE_ENUM (LOOKUP_CREATE ); -TRACE_DEFINE_ENUM (LOOKUP_EXCL ); -TRACE_DEFINE_ENUM (LOOKUP_RENAME_TARGET ); -TRACE_DEFINE_ENUM (LOOKUP_EMPTY ); -TRACE_DEFINE_ENUM (LOOKUP_DOWN ); -#define show_lookup_flags (flags) \ __print_flags(flags, "|", \ { LOOKUP_FOLLOW, "FOLLOW" }, \
@@ -392,22 +340,6 @@ DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit);DEFINE_NFS_LOOKUP_EVENT (nfs_lookup_revalidate_enter);DEFINE_NFS_LOOKUP_EVENT_DONE (nfs_lookup_revalidate_exit); -TRACE_DEFINE_ENUM (O_WRONLY ); -TRACE_DEFINE_ENUM (O_RDWR ); -TRACE_DEFINE_ENUM (O_CREAT ); -TRACE_DEFINE_ENUM (O_EXCL ); -TRACE_DEFINE_ENUM (O_NOCTTY ); -TRACE_DEFINE_ENUM (O_TRUNC ); -TRACE_DEFINE_ENUM (O_APPEND ); -TRACE_DEFINE_ENUM (O_NONBLOCK ); -TRACE_DEFINE_ENUM (O_DSYNC ); -TRACE_DEFINE_ENUM (O_DIRECT ); -TRACE_DEFINE_ENUM (O_LARGEFILE ); -TRACE_DEFINE_ENUM (O_DIRECTORY ); -TRACE_DEFINE_ENUM (O_NOFOLLOW ); -TRACE_DEFINE_ENUM (O_NOATIME ); -TRACE_DEFINE_ENUM (O_CLOEXEC ); -#define show_open_flags (flags) \ __print_flags(flags, "|", \ { O_WRONLY, "O_WRONLY" }, \
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 196/690 SUNRPC: Tracepoints should display tk_pid and cl_clid as a fixed-size field
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit b4776a341ec05e809d21e98db5ed49dbdc81d5d8 ]
For certain special cases, RPC-related tracepoints record a -1 as the task ID or the client ID. It's ugly for a trace event to display 4 billion in these cases.
To help keep SUNRPC tracepoints consistent, create a macro that defines the print format specifiers for tk_pid and cl_clid. At some point in the future we might try tk_pid with a wider range of values than 0..64K so this makes it easier to make that change.
RPC tracepoints now look like this:
<...>-1276 [009] 149.720358: rpc_clnt_new: client=00000005 peer=[192.168.2.55]:20049 program=nfs server=klimt.ib
<...>-1342 [004] 149.921234: rpc_xdr_recvfrom: task:0000001a@00000005 head=[0xff1242d9ab6dc01c,144] page=0 tail=[(nil),0] len=144 <...>-1342 [004] 149.921235: xprt_release_cong: task:0000001a@00000005 snd_task:ffffffff cong=256 cwnd=16384 <...>-1342 [004] 149.921235: xprt_put_cong: task:0000001a@00000005 snd_task:ffffffff cong=0 cwnd=16384
--- fs/nfs/nfs4trace.h | 9 ++-- fs/nfs/nfstrace.h | 6 ++- include/trace/events/rpcgss.h | 18 +++++--- include/trace/events/rpcrdma.h | 42 +++++++++-------- include/trace/events/sunrpc.h | 74 ++++++++++++++++++------------ include/trace/events/sunrpc_base.h | 18 ++++++++ 6 files changed, 108 insertions(+), 59 deletions(-) create mode 100644 include/trace/events/sunrpc_base.h
fs/nfs/nfs4trace.h +5 -4
@@ -9,6 +9,7 @@#define _TRACE_NFS4_H#include <linux/tracepoint.h> +#include <trace/events/sunrpc_base.h> TRACE_DEFINE_ENUM (EPERM );TRACE_DEFINE_ENUM (ENOENT );
@@ -696,8 +697,8 @@ TRACE_EVENT(nfs4_xdr_bad_operation, __entry->expected = expected; ), -TP_printk ( -"task:%u@%d xid=0x%08x operation=%u, expected=%u" , +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER +" xid=0x%08x operation=%u, expected=%u" , __entry->task_id, __entry->client_id, __entry->xid, __entry->op, __entry->expected )
@@ -731,8 +732,8 @@ DECLARE_EVENT_CLASS(nfs4_xdr_event, __entry->error = error; ), -TP_printk ( -"task:%u@%d xid=0x%08x error=%ld (%s) operation=%u" , +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER +" xid=0x%08x error=%ld (%s) operation=%u" , __entry->task_id, __entry->client_id, __entry->xid, -__entry->error,show_nfsv4_errors (__entry->error), __entry->op
fs/nfs/nfstrace.h +4 -2
@@ -11,6 +11,8 @@#include <linux/tracepoint.h> #include <linux/iversion.h> +#include <trace/events/sunrpc_base.h> +#define nfs_show_file_type (ftype) \ __print_symbolic(ftype, \ { DT_UNKNOWN, "UNKNOWN" }, \
@@ -1359,8 +1361,8 @@ DECLARE_EVENT_CLASS(nfs_xdr_event,__assign_str (procedure, task->tk_msg.rpc_proc->p_name); ), - TP_printk( - "task:%u@%d xid=0x%08x %sv%d %s error=%ld (%s)", + TP_printk(SUNRPC_TRACE_TASK_SPECIFIER + " xid=0x%08x %sv%d %s error=%ld (%s)", __entry->task_id, __entry->client_id, __entry->xid, __get_str(program), __entry->version, __get_str(procedure), -__entry->error,
include/trace/events/rpcgss.h +12 -6
@@ -13,6 +13,8 @@#include <linux/tracepoint.h> +#include <trace/events/sunrpc_base.h> +/** ** GSS-API related trace events **/
@@ -99,7 +101,7 @@ DECLARE_EVENT_CLASS(rpcgss_gssapi_event, __entry->maj_stat = maj_stat; ), -TP_printk ("task:%u@%u maj_stat=%s" , +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER " maj_stat=%s" , __entry->task_id, __entry->client_id, __entry->maj_stat ==0 ?"GSS_S_COMPLETE" :show_gss_status (__entry->maj_stat))
@@ -332,7 +334,8 @@ TRACE_EVENT(rpcgss_unwrap_failed, __entry->client_id = task->tk_client->cl_clid; ), -TP_printk ("task:%u@%u" , __entry->task_id, __entry->client_id) +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER , + __entry->task_id, __entry->client_id) ); TRACE_EVENT(rpcgss_bad_seqno,
@@ -358,7 +361,8 @@ TRACE_EVENT(rpcgss_bad_seqno, __entry->received = received; ), -TP_printk ("task:%u@%u expected seqno %u, received seqno %u" , +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER +" expected seqno %u, received seqno %u" , __entry->task_id, __entry->client_id, __entry->expected, __entry->received) );
@@ -386,7 +390,7 @@ TRACE_EVENT(rpcgss_seqno, __entry->seqno = rqst->rq_seqno; ), -TP_printk ("task:%u@%u xid=0x%08x seqno=%u" , +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x seqno=%u" , __entry->task_id, __entry->client_id, __entry->xid, __entry->seqno) );
@@ -418,7 +422,8 @@ TRACE_EVENT(rpcgss_need_reencode, __entry->ret = ret; ), -TP_printk ("task:%u@%u xid=0x%08x rq_seqno=%u seq_xmit=%u reencode %sneeded" , +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER +" xid=0x%08x rq_seqno=%u seq_xmit=%u reencode %sneeded" , __entry->task_id, __entry->client_id, __entry->xid, __entry->seqno, __entry->seq_xmit, __entry->ret ?"" :"un" )
@@ -452,7 +457,8 @@ TRACE_EVENT(rpcgss_update_slack, __entry->verfsize = auth->au_verfsize; ), -TP_printk ("task:%u@%u xid=0x%08x auth=%p rslack=%u ralign=%u verfsize=%u\n" , +TP_printk (SUNRPC_TRACE_TASK_SPECIFIER +" xid=0x%08x auth=%p rslack=%u ralign=%u verfsize=%u\n" , __entry->task_id, __entry->client_id, __entry->xid, __entry->auth, __entry->rslack, __entry->ralign, __entry->verfsize)
include/trace/events/rpcrdma.h +24 -18
145 lines not on this page · raw message
include/trace/events/sunrpc.h +45 -29
224 lines not on this page · raw message
include/trace/events/sunrpc_base.h new file +18 -0
@@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (c) 2021 Oracle and/or its affiliates. +* +* Common types and format specifiers for sunrpc. +*/ + +#if !defined(_TRACE_SUNRPC_BASE_H) +#define _TRACE_SUNRPC_BASE_H + +#include <linux/tracepoint.h> + +#define SUNRPC_TRACE_PID_SPECIFIER "%08x" +#define SUNRPC_TRACE_CLID_SPECIFIER "%08x" +#define SUNRPC_TRACE_TASK_SPECIFIER \ + "task:" SUNRPC_TRACE_PID_SPECIFIER "@" SUNRPC_TRACE_CLID_SPECIFIER + +#endif /* _TRACE_SUNRPC_BASE_H */
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 197/690 NFS: Move generic FS show macros to global header
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit 9d2d48bbbdabf7b2f029369c4f926d133c1d47ad ]
Refactor: Surface useful show_ macros for use by other trace subsystems.
--- fs/nfs/nfs4trace.h | 67 ++++++--------------- fs/nfs/nfstrace.h | 80 +++++-------------------- include/trace/events/fs.h | 122 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 156 insertions(+), 113 deletions(-) create mode 100644 include/trace/events/fs.h
fs/nfs/nfs4trace.h +19 -48
@@ -11,6 +11,8 @@#include <linux/tracepoint.h> #include <trace/events/sunrpc_base.h> +#include <trace/events/fs.h> +TRACE_DEFINE_ENUM (EPERM );TRACE_DEFINE_ENUM (ENOENT );TRACE_DEFINE_ENUM (EIO );
@@ -314,19 +316,6 @@ TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_PNFS); { NFS4ERR_RESET_TO_MDS, "RESET_TO_MDS" }, \ { NFS4ERR_RESET_TO_PNFS, "RESET_TO_PNFS" }) -#define show_open_flags (flags) \ - __print_flags(flags, "|", \ - { O_CREAT, "O_CREAT" }, \ - { O_EXCL, "O_EXCL" }, \ - { O_TRUNC, "O_TRUNC" }, \ - { O_DIRECT, "O_DIRECT" }) - -#define show_fmode_flags (mode) \ - __print_flags(mode, "|", \ - { ((__force unsigned long)FMODE_READ), "READ" }, \ - { ((__force unsigned long)FMODE_WRITE), "WRITE" }, \ - { ((__force unsigned long)FMODE_EXEC), "EXEC" }) -#define show_nfs_fattr_flags (valid) \ __print_flags((unsigned long)valid, "|", \ { NFS_ATTR_FATTR_TYPE, "TYPE" }, \
@@ -796,8 +785,8 @@ DECLARE_EVENT_CLASS(nfs4_open_event,TP_STRUCT__entry (__field (unsigned long ,error ) - __field(unsigned int, flags) - __field(unsigned int, fmode) + __field(unsigned long, flags) + __field(unsigned long, fmode)__field (dev_t, dev)__field (u32, fhandle) __field(u64, fileid)
@@ -815,7 +804,7 @@ DECLARE_EVENT_CLASS(nfs4_open_event, __entry->error = -error; __entry->flags = flags; - __entry->fmode = (__force unsigned int )ctx->mode; + __entry->fmode = (__force unsigned long )ctx->mode; __entry->dev = ctx->dentry->d_sb->s_dev;if (!IS_ERR_OR_NULL (state)) { inode = state->inode;
@@ -845,15 +834,15 @@ DECLARE_EVENT_CLASS(nfs4_open_event, ), TP_printk( - "error=%ld (%s) flags=%d (%s) fmode=%s " + "error=%ld (%s) flags=%lu (%s) fmode=%s " "fileid=%02x:%02x:%llu fhandle=0x%08x " "name=%02x:%02x:%llu/%s stateid=%d:0x%08x " "openstateid=%d:0x%08x", -__entry->error, show_nfsv4_errors(__entry->error), __entry->flags, - show_open_flags(__entry->flags), - show_fmode_flags(__entry->fmode), + show_fs_fcntl_open_flags(__entry->flags), + show_fs_fmode_flags(__entry->fmode), MAJOR(__entry->dev), MINOR(__entry->dev), (unsigned long long)__entry->fileid, __entry->fhandle,
@@ -907,7 +896,7 @@ TRACE_EVENT(nfs4_cached_open, TP_printk( "fmode=%s fileid=%02x:%02x:%llu " "fhandle=0x%08x stateid=%d:0x%08x", - __entry->fmode ? show_fmode_flags(__entry->fmode) : + __entry->fmode ? show_fs_fmode_flags(__entry->fmode) : "closed", MAJOR(__entry->dev), MINOR(__entry->dev), (unsigned long long)__entry->fileid,
@@ -955,7 +944,7 @@ TRACE_EVENT(nfs4_close,"fhandle=0x%08x openstateid=%d:0x%08x" , -__entry->error,show_nfsv4_errors (__entry->error), - __entry->fmode ?show_fmode_flags (__entry->fmode) : + __entry->fmode ?show_fs_fmode_flags (__entry->fmode) :"closed" ,MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long)__entry->fileid,
@@ -964,24 +953,6 @@ TRACE_EVENT(nfs4_close, ) ); -TRACE_DEFINE_ENUM (F_GETLK ); -TRACE_DEFINE_ENUM (F_SETLK ); -TRACE_DEFINE_ENUM (F_SETLKW ); -TRACE_DEFINE_ENUM (F_RDLCK ); -TRACE_DEFINE_ENUM (F_WRLCK ); -TRACE_DEFINE_ENUM (F_UNLCK ); - -#define show_lock_cmd (type) \ - __print_symbolic((int)type, \ - { F_GETLK, "GETLK" }, \ - { F_SETLK, "SETLK" }, \ - { F_SETLKW, "SETLKW" }) -#define show_lock_type (type) \ - __print_symbolic((int)type, \ - { F_RDLCK, "RDLCK" }, \ - { F_WRLCK, "WRLCK" }, \ - { F_UNLCK, "UNLCK" }) - DECLARE_EVENT_CLASS(nfs4_lock_event, TP_PROTO( const struct file_lock *request,
@@ -994,8 +965,8 @@ DECLARE_EVENT_CLASS(nfs4_lock_event,TP_STRUCT__entry (__field (unsigned long ,error ) -__field (int, cmd) -__field (char, type) + __field(unsigned long, cmd) + __field(unsigned long, type)__field (loff_t, start)__field (loff_t, end) __field(dev_t, dev)
@@ -1028,8 +999,8 @@ DECLARE_EVENT_CLASS(nfs4_lock_event,"stateid=%d:0x%08x" , -__entry->error,show_nfsv4_errors (__entry->error), -show_lock_cmd (__entry->cmd), -show_lock_type (__entry->type), +show_fs_fcntl_cmd (__entry->cmd), +show_fs_fcntl_lock_type (__entry->type), (long long )__entry->start, (long long )__entry->end, MAJOR(__entry->dev), MINOR(__entry->dev),
@@ -1064,8 +1035,8 @@ TRACE_EVENT(nfs4_set_lock,TP_STRUCT__entry (__field (unsigned long ,error ) -__field (int, cmd) -__field (char, type) + __field(unsigned long, cmd) + __field(unsigned long, type)__field (loff_t, start)__field (loff_t, end) __field(dev_t, dev)
@@ -1104,8 +1075,8 @@ TRACE_EVENT(nfs4_set_lock,"stateid=%d:0x%08x lockstateid=%d:0x%08x" , -__entry->error,show_nfsv4_errors (__entry->error), -show_lock_cmd (__entry->cmd), -show_lock_type (__entry->type), +show_fs_fcntl_cmd (__entry->cmd), +show_fs_fcntl_lock_type (__entry->type), (long long )__entry->start, (long long )__entry->end, MAJOR(__entry->dev), MINOR(__entry->dev),
@@ -1222,7 +1193,7 @@ DECLARE_EVENT_CLASS(nfs4_set_delegation_event,TP_printk ("fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x" , -show_fmode_flags (__entry->fmode), +show_fs_fmode_flags (__entry->fmode),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle
fs/nfs/nfstrace.h +15 -65
172 lines not on this page · raw message
include/trace/events/fs.h new file +122 -0
122 lines not on this page · raw message
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 198/690 NFS: Move NFS protocol display macros to global header
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit 8791545eda52e8f3bc48e3cd902e38bf4ba4c9de ]
Refactor: surface useful show_ macros so they can be shared between the client and server trace code.
Additional clean up:
- Housekeeping: ensure the correct #include files are pulled in and add proper TRACE_DEFINE_ENUM where they are missing
- Use a consistent naming scheme for the helpers
- Store values to be displayed symbolically as unsigned long, as that is the type that the __print_yada() functions take
--- fs/nfs/nfs4trace.h | 403 ++++--------------------------------- fs/nfs/nfstrace.h | 117 ++--------- fs/nfs/pnfs.h | 4 - fs/nfsd/trace.h | 1 + include/linux/nfs4.h | 4 + include/trace/events/nfs.h | 375 ++++++++++++++++++++++++++++++++++ 6 files changed, 433 insertions(+), 471 deletions(-) create mode 100644 include/trace/events/nfs.h
fs/nfs/nfs4trace.h +34 -369
@@ -12,309 +12,7 @@#include <trace/events/sunrpc_base.h> #include <trace/events/fs.h> - -TRACE_DEFINE_ENUM (EPERM ); -TRACE_DEFINE_ENUM (ENOENT ); -TRACE_DEFINE_ENUM (EIO ); -TRACE_DEFINE_ENUM (ENXIO ); -TRACE_DEFINE_ENUM (EACCES ); -TRACE_DEFINE_ENUM (EEXIST ); -TRACE_DEFINE_ENUM (EXDEV ); -TRACE_DEFINE_ENUM (ENOTDIR ); -TRACE_DEFINE_ENUM (EISDIR ); -TRACE_DEFINE_ENUM (EFBIG ); -TRACE_DEFINE_ENUM (ENOSPC ); -TRACE_DEFINE_ENUM (EROFS ); -TRACE_DEFINE_ENUM (EMLINK ); -TRACE_DEFINE_ENUM (ENAMETOOLONG ); -TRACE_DEFINE_ENUM (ENOTEMPTY ); -TRACE_DEFINE_ENUM (EDQUOT ); -TRACE_DEFINE_ENUM (ESTALE ); -TRACE_DEFINE_ENUM (EBADHANDLE ); -TRACE_DEFINE_ENUM (EBADCOOKIE ); -TRACE_DEFINE_ENUM (ENOTSUPP ); -TRACE_DEFINE_ENUM (ETOOSMALL ); -TRACE_DEFINE_ENUM (EREMOTEIO ); -TRACE_DEFINE_ENUM (EBADTYPE ); -TRACE_DEFINE_ENUM (EAGAIN ); -TRACE_DEFINE_ENUM (ELOOP ); -TRACE_DEFINE_ENUM (EOPNOTSUPP ); -TRACE_DEFINE_ENUM (EDEADLK ); -TRACE_DEFINE_ENUM (ENOMEM ); -TRACE_DEFINE_ENUM (EKEYEXPIRED ); -TRACE_DEFINE_ENUM (ETIMEDOUT ); -TRACE_DEFINE_ENUM (ERESTARTSYS ); -TRACE_DEFINE_ENUM (ECONNREFUSED ); -TRACE_DEFINE_ENUM (ECONNRESET ); -TRACE_DEFINE_ENUM (ENETUNREACH ); -TRACE_DEFINE_ENUM (EHOSTUNREACH ); -TRACE_DEFINE_ENUM (EHOSTDOWN ); -TRACE_DEFINE_ENUM (EPIPE ); -TRACE_DEFINE_ENUM (EPFNOSUPPORT ); -TRACE_DEFINE_ENUM (EPROTONOSUPPORT ); - -TRACE_DEFINE_ENUM (NFS4_OK ); -TRACE_DEFINE_ENUM (NFS4ERR_ACCESS ); -TRACE_DEFINE_ENUM (NFS4ERR_ATTRNOTSUPP ); -TRACE_DEFINE_ENUM (NFS4ERR_ADMIN_REVOKED ); -TRACE_DEFINE_ENUM (NFS4ERR_BACK_CHAN_BUSY ); -TRACE_DEFINE_ENUM (NFS4ERR_BADCHAR ); -TRACE_DEFINE_ENUM (NFS4ERR_BADHANDLE ); -TRACE_DEFINE_ENUM (NFS4ERR_BADIOMODE ); -TRACE_DEFINE_ENUM (NFS4ERR_BADLAYOUT ); -TRACE_DEFINE_ENUM (NFS4ERR_BADLABEL ); -TRACE_DEFINE_ENUM (NFS4ERR_BADNAME ); -TRACE_DEFINE_ENUM (NFS4ERR_BADOWNER ); -TRACE_DEFINE_ENUM (NFS4ERR_BADSESSION ); -TRACE_DEFINE_ENUM (NFS4ERR_BADSLOT ); -TRACE_DEFINE_ENUM (NFS4ERR_BADTYPE ); -TRACE_DEFINE_ENUM (NFS4ERR_BADXDR ); -TRACE_DEFINE_ENUM (NFS4ERR_BAD_COOKIE ); -TRACE_DEFINE_ENUM (NFS4ERR_BAD_HIGH_SLOT ); -TRACE_DEFINE_ENUM (NFS4ERR_BAD_RANGE ); -TRACE_DEFINE_ENUM (NFS4ERR_BAD_SEQID ); -TRACE_DEFINE_ENUM (NFS4ERR_BAD_SESSION_DIGEST ); -TRACE_DEFINE_ENUM (NFS4ERR_BAD_STATEID ); -TRACE_DEFINE_ENUM (NFS4ERR_CB_PATH_DOWN ); -TRACE_DEFINE_ENUM (NFS4ERR_CLID_INUSE ); -TRACE_DEFINE_ENUM (NFS4ERR_CLIENTID_BUSY ); -TRACE_DEFINE_ENUM (NFS4ERR_COMPLETE_ALREADY ); -TRACE_DEFINE_ENUM (NFS4ERR_CONN_NOT_BOUND_TO_SESSION ); -TRACE_DEFINE_ENUM (NFS4ERR_DEADLOCK ); -TRACE_DEFINE_ENUM (NFS4ERR_DEADSESSION ); -TRACE_DEFINE_ENUM (NFS4ERR_DELAY ); -TRACE_DEFINE_ENUM (NFS4ERR_DELEG_ALREADY_WANTED ); -TRACE_DEFINE_ENUM (NFS4ERR_DELEG_REVOKED ); -TRACE_DEFINE_ENUM (NFS4ERR_DENIED ); -TRACE_DEFINE_ENUM (NFS4ERR_DIRDELEG_UNAVAIL ); -TRACE_DEFINE_ENUM (NFS4ERR_DQUOT ); -TRACE_DEFINE_ENUM (NFS4ERR_ENCR_ALG_UNSUPP ); -TRACE_DEFINE_ENUM (NFS4ERR_EXIST ); -TRACE_DEFINE_ENUM (NFS4ERR_EXPIRED ); -TRACE_DEFINE_ENUM (NFS4ERR_FBIG ); -TRACE_DEFINE_ENUM (NFS4ERR_FHEXPIRED ); -TRACE_DEFINE_ENUM (NFS4ERR_FILE_OPEN ); -TRACE_DEFINE_ENUM (NFS4ERR_GRACE ); -TRACE_DEFINE_ENUM (NFS4ERR_HASH_ALG_UNSUPP ); -TRACE_DEFINE_ENUM (NFS4ERR_INVAL ); -TRACE_DEFINE_ENUM (NFS4ERR_IO ); -TRACE_DEFINE_ENUM (NFS4ERR_ISDIR ); -TRACE_DEFINE_ENUM (NFS4ERR_LAYOUTTRYLATER ); -TRACE_DEFINE_ENUM (NFS4ERR_LAYOUTUNAVAILABLE ); -TRACE_DEFINE_ENUM (NFS4ERR_LEASE_MOVED ); -TRACE_DEFINE_ENUM (NFS4ERR_LOCKED ); -TRACE_DEFINE_ENUM (NFS4ERR_LOCKS_HELD ); -TRACE_DEFINE_ENUM (NFS4ERR_LOCK_RANGE ); -TRACE_DEFINE_ENUM (NFS4ERR_MINOR_VERS_MISMATCH ); -TRACE_DEFINE_ENUM (NFS4ERR_MLINK ); -TRACE_DEFINE_ENUM (NFS4ERR_MOVED ); -TRACE_DEFINE_ENUM (NFS4ERR_NAMETOOLONG ); -TRACE_DEFINE_ENUM (NFS4ERR_NOENT ); -TRACE_DEFINE_ENUM (NFS4ERR_NOFILEHANDLE ); -TRACE_DEFINE_ENUM (NFS4ERR_NOMATCHING_LAYOUT ); -TRACE_DEFINE_ENUM (NFS4ERR_NOSPC ); -TRACE_DEFINE_ENUM (NFS4ERR_NOTDIR ); -TRACE_DEFINE_ENUM (NFS4ERR_NOTEMPTY ); -TRACE_DEFINE_ENUM (NFS4ERR_NOTSUPP ); -TRACE_DEFINE_ENUM (NFS4ERR_NOT_ONLY_OP ); -TRACE_DEFINE_ENUM (NFS4ERR_NOT_SAME ); -TRACE_DEFINE_ENUM (NFS4ERR_NO_GRACE ); -TRACE_DEFINE_ENUM (NFS4ERR_NXIO ); -TRACE_DEFINE_ENUM (NFS4ERR_OLD_STATEID ); -TRACE_DEFINE_ENUM (NFS4ERR_OPENMODE ); -TRACE_DEFINE_ENUM (NFS4ERR_OP_ILLEGAL ); -TRACE_DEFINE_ENUM (NFS4ERR_OP_NOT_IN_SESSION ); -TRACE_DEFINE_ENUM (NFS4ERR_PERM ); -TRACE_DEFINE_ENUM (NFS4ERR_PNFS_IO_HOLE ); -TRACE_DEFINE_ENUM (NFS4ERR_PNFS_NO_LAYOUT ); -TRACE_DEFINE_ENUM (NFS4ERR_RECALLCONFLICT ); -TRACE_DEFINE_ENUM (NFS4ERR_RECLAIM_BAD ); -TRACE_DEFINE_ENUM (NFS4ERR_RECLAIM_CONFLICT ); -TRACE_DEFINE_ENUM (NFS4ERR_REJECT_DELEG ); -TRACE_DEFINE_ENUM (NFS4ERR_REP_TOO_BIG ); -TRACE_DEFINE_ENUM (NFS4ERR_REP_TOO_BIG_TO_CACHE ); -TRACE_DEFINE_ENUM (NFS4ERR_REQ_TOO_BIG ); -TRACE_DEFINE_ENUM (NFS4ERR_RESOURCE ); -TRACE_DEFINE_ENUM (NFS4ERR_RESTOREFH ); -TRACE_DEFINE_ENUM (NFS4ERR_RETRY_UNCACHED_REP ); -TRACE_DEFINE_ENUM (NFS4ERR_RETURNCONFLICT ); -TRACE_DEFINE_ENUM (NFS4ERR_ROFS ); -TRACE_DEFINE_ENUM (NFS4ERR_SAME ); -TRACE_DEFINE_ENUM (NFS4ERR_SHARE_DENIED ); -TRACE_DEFINE_ENUM (NFS4ERR_SEQUENCE_POS ); -TRACE_DEFINE_ENUM (NFS4ERR_SEQ_FALSE_RETRY ); -TRACE_DEFINE_ENUM (NFS4ERR_SEQ_MISORDERED ); -TRACE_DEFINE_ENUM (NFS4ERR_SERVERFAULT ); -TRACE_DEFINE_ENUM (NFS4ERR_STALE ); -TRACE_DEFINE_ENUM (NFS4ERR_STALE_CLIENTID ); -TRACE_DEFINE_ENUM (NFS4ERR_STALE_STATEID ); -TRACE_DEFINE_ENUM (NFS4ERR_SYMLINK ); -TRACE_DEFINE_ENUM (NFS4ERR_TOOSMALL ); -TRACE_DEFINE_ENUM (NFS4ERR_TOO_MANY_OPS ); -TRACE_DEFINE_ENUM (NFS4ERR_UNKNOWN_LAYOUTTYPE ); -TRACE_DEFINE_ENUM (NFS4ERR_UNSAFE_COMPOUND ); -TRACE_DEFINE_ENUM (NFS4ERR_WRONGSEC ); -TRACE_DEFINE_ENUM (NFS4ERR_WRONG_CRED ); -TRACE_DEFINE_ENUM (NFS4ERR_WRONG_TYPE ); -TRACE_DEFINE_ENUM (NFS4ERR_XDEV ); - -TRACE_DEFINE_ENUM (NFS4ERR_RESET_TO_MDS ); -TRACE_DEFINE_ENUM (NFS4ERR_RESET_TO_PNFS ); - -#define show_nfsv4_errors (error) \ - __print_symbolic(error, \ - { NFS4_OK, "OK" }, \ -/* Mapped by nfs4_stat_to_errno() */ \ - { EPERM, "EPERM" }, \ - { ENOENT, "ENOENT" }, \ - { EIO, "EIO" }, \ - { ENXIO, "ENXIO" }, \ - { EACCES, "EACCES" }, \ - { EEXIST, "EEXIST" }, \ - { EXDEV, "EXDEV" }, \ - { ENOTDIR, "ENOTDIR" }, \ - { EISDIR, "EISDIR" }, \ - { EFBIG, "EFBIG" }, \ - { ENOSPC, "ENOSPC" }, \ - { EROFS, "EROFS" }, \ - { EMLINK, "EMLINK" }, \ - { ENAMETOOLONG, "ENAMETOOLONG" }, \ - { ENOTEMPTY, "ENOTEMPTY" }, \ - { EDQUOT, "EDQUOT" }, \ - { ESTALE, "ESTALE" }, \ - { EBADHANDLE, "EBADHANDLE" }, \ - { EBADCOOKIE, "EBADCOOKIE" }, \ - { ENOTSUPP, "ENOTSUPP" }, \ - { ETOOSMALL, "ETOOSMALL" }, \ - { EREMOTEIO, "EREMOTEIO" }, \ - { EBADTYPE, "EBADTYPE" }, \ - { EAGAIN, "EAGAIN" }, \ - { ELOOP, "ELOOP" }, \ - { EOPNOTSUPP, "EOPNOTSUPP" }, \ - { EDEADLK, "EDEADLK" }, \ -/* RPC errors */ \ - { ENOMEM, "ENOMEM" }, \ - { EKEYEXPIRED, "EKEYEXPIRED" }, \ - { ETIMEDOUT, "ETIMEDOUT" }, \ - { ERESTARTSYS, "ERESTARTSYS" }, \ - { ECONNREFUSED, "ECONNREFUSED" }, \ - { ECONNRESET, "ECONNRESET" }, \ - { ENETUNREACH, "ENETUNREACH" }, \ - { EHOSTUNREACH, "EHOSTUNREACH" }, \ - { EHOSTDOWN, "EHOSTDOWN" }, \ - { EPIPE, "EPIPE" }, \ - { EPFNOSUPPORT, "EPFNOSUPPORT" }, \ - { EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \ -/* NFSv4 native errors */ \ - { NFS4ERR_ACCESS, "ACCESS" }, \ - { NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \ - { NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \ - { NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \ - { NFS4ERR_BADCHAR, "BADCHAR" }, \ - { NFS4ERR_BADHANDLE, "BADHANDLE" }, \ - { NFS4ERR_BADIOMODE, "BADIOMODE" }, \ - { NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \ - { NFS4ERR_BADLABEL, "BADLABEL" }, \ - { NFS4ERR_BADNAME, "BADNAME" }, \ - { NFS4ERR_BADOWNER, "BADOWNER" }, \ - { NFS4ERR_BADSESSION, "BADSESSION" }, \ - { NFS4ERR_BADSLOT, "BADSLOT" }, \ - { NFS4ERR_BADTYPE, "BADTYPE" }, \ - { NFS4ERR_BADXDR, "BADXDR" }, \ - { NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \ - { NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \ - { NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \ - { NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \ - { NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \ - { NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \ - { NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \ - { NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \ - { NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \ - { NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \ - { NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \ - "CONN_NOT_BOUND_TO_SESSION" }, \ - { NFS4ERR_DEADLOCK, "DEADLOCK" }, \ - { NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \ - { NFS4ERR_DELAY, "DELAY" }, \ - { NFS4ERR_DELEG_ALREADY_WANTED, \ - "DELEG_ALREADY_WANTED" }, \ - { NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \ - { NFS4ERR_DENIED, "DENIED" }, \ - { NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \ - { NFS4ERR_DQUOT, "DQUOT" }, \ - { NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \ - { NFS4ERR_EXIST, "EXIST" }, \ - { NFS4ERR_EXPIRED, "EXPIRED" }, \ - { NFS4ERR_FBIG, "FBIG" }, \ - { NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \ - { NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \ - { NFS4ERR_GRACE, "GRACE" }, \ - { NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \ - { NFS4ERR_INVAL, "INVAL" }, \ - { NFS4ERR_IO, "IO" }, \ - { NFS4ERR_ISDIR, "ISDIR" }, \ - { NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \ - { NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \ - { NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \ - { NFS4ERR_LOCKED, "LOCKED" }, \ - { NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \ - { NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \ - { NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \ - { NFS4ERR_MLINK, "MLINK" }, \ - { NFS4ERR_MOVED, "MOVED" }, \ - { NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \ - { NFS4ERR_NOENT, "NOENT" }, \ - { NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \ - { NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \ - { NFS4ERR_NOSPC, "NOSPC" }, \ - { NFS4ERR_NOTDIR, "NOTDIR" }, \ - { NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \ - { NFS4ERR_NOTSUPP, "NOTSUPP" }, \ - { NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \ - { NFS4ERR_NOT_SAME, "NOT_SAME" }, \ - { NFS4ERR_NO_GRACE, "NO_GRACE" }, \ - { NFS4ERR_NXIO, "NXIO" }, \ - { NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \ - { NFS4ERR_OPENMODE, "OPENMODE" }, \ - { NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \ - { NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \ - { NFS4ERR_PERM, "PERM" }, \ - { NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \ - { NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \ - { NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \ - { NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \ - { NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \ - { NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \ - { NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \ - { NFS4ERR_REP_TOO_BIG_TO_CACHE, \ - "REP_TOO_BIG_TO_CACHE" }, \ - { NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \ - { NFS4ERR_RESOURCE, "RESOURCE" }, \ - { NFS4ERR_RESTOREFH, "RESTOREFH" }, \ - { NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \ - { NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \ - { NFS4ERR_ROFS, "ROFS" }, \ - { NFS4ERR_SAME, "SAME" }, \ - { NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \ - { NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \ - { NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \ - { NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \ - { NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \ - { NFS4ERR_STALE, "STALE" }, \ - { NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \ - { NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \ - { NFS4ERR_SYMLINK, "SYMLINK" }, \ - { NFS4ERR_TOOSMALL, "TOOSMALL" }, \ - { NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \ - { NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \ - { NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \ - { NFS4ERR_WRONGSEC, "WRONGSEC" }, \ - { NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \ - { NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \ - { NFS4ERR_XDEV, "XDEV" }, \ - /* ***** Internal to Linux NFS client ***** */ \ - { NFS4ERR_RESET_TO_MDS, "RESET_TO_MDS" }, \ - { NFS4ERR_RESET_TO_PNFS, "RESET_TO_PNFS" }) +#include <trace/events/nfs.h> #define show_nfs_fattr_flags (valid) \ __print_flags((unsigned long)valid, "|", \
@@ -355,7 +53,7 @@ DECLARE_EVENT_CLASS(nfs4_clientid_event,TP_printk ("error=%ld (%s) dstaddr=%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),__get_str (dstaddr) ) );
@@ -379,29 +77,6 @@ DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);DEFINE_NFS4_CLIENTID_EVENT (nfs4_sequence);DEFINE_NFS4_CLIENTID_EVENT (nfs4_reclaim_complete); -#define show_nfs4_sequence_status_flags (status) \ - __print_flags((unsigned long)status, "|", \ - { SEQ4_STATUS_CB_PATH_DOWN, "CB_PATH_DOWN" }, \ - { SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING, \ - "CB_GSS_CONTEXTS_EXPIRING" }, \ - { SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED, \ - "CB_GSS_CONTEXTS_EXPIRED" }, \ - { SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED, \ - "EXPIRED_ALL_STATE_REVOKED" }, \ - { SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED, \ - "EXPIRED_SOME_STATE_REVOKED" }, \ - { SEQ4_STATUS_ADMIN_STATE_REVOKED, \ - "ADMIN_STATE_REVOKED" }, \ - { SEQ4_STATUS_RECALLABLE_STATE_REVOKED, \ - "RECALLABLE_STATE_REVOKED" }, \ - { SEQ4_STATUS_LEASE_MOVED, "LEASE_MOVED" }, \ - { SEQ4_STATUS_RESTART_RECLAIM_NEEDED, \ - "RESTART_RECLAIM_NEEDED" }, \ - { SEQ4_STATUS_CB_PATH_DOWN_SESSION, \ - "CB_PATH_DOWN_SESSION" }, \ - { SEQ4_STATUS_BACKCHANNEL_FAULT, \ - "BACKCHANNEL_FAULT" }) - TRACE_EVENT(nfs4_sequence_done, TP_PROTO( const struct nfs4_session *session,
@@ -415,7 +90,7 @@ TRACE_EVENT(nfs4_sequence_done, __field(unsigned int, seq_nr) __field(unsigned int, highest_slotid) __field(unsigned int, target_highest_slotid) - __field(unsigned int, status_flags) + __field(unsigned long, status_flags) __field(unsigned long, error) ),
@@ -434,16 +109,16 @@ TRACE_EVENT(nfs4_sequence_done,TP_printk ("error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u " "highest_slotid=%u target_highest_slotid=%u " -"status_flags=%u (%s)" , +"status_flags=0x%lx (%s)" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error), __entry->session, __entry->slot_nr, __entry->seq_nr, __entry->highest_slotid, __entry->target_highest_slotid, __entry->status_flags, -show_nfs4_sequence_status_flags (__entry->status_flags) +show_nfs4_seq4_status (__entry->status_flags) ) );
@@ -480,7 +155,7 @@ TRACE_EVENT(nfs4_cb_sequence,"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u " "highest_slotid=%u" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error), __entry->session, __entry->slot_nr, __entry->seq_nr,
@@ -517,7 +192,7 @@ TRACE_EVENT(nfs4_cb_seqid_err,"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u " "highest_slotid=%u" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error), __entry->session, __entry->slot_nr, __entry->seq_nr,
@@ -653,7 +328,7 @@ TRACE_EVENT(nfs4_state_mgr_failed,"hostname=%s clp state=%s error=%ld (%s) section=%s" ,__get_str (hostname),show_nfs4_clp_state (__entry->state), -__entry->error, -show_nfsv4_errors (__entry->error),__get_str (section) +show_nfs4_status (__entry->error),__get_str (section) ) )
@@ -724,7 +399,7 @@ DECLARE_EVENT_CLASS(nfs4_xdr_event,TP_printk (SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x error=%ld (%s) operation=%u" , __entry->task_id, __entry->client_id, __entry->xid, - -__entry->error,show_nfsv4_errors (__entry->error), + -__entry->error,show_nfs4_status (__entry->error), __entry->op ) );
@@ -839,7 +514,7 @@ DECLARE_EVENT_CLASS(nfs4_open_event,"name=%02x:%02x:%llu/%s stateid=%d:0x%08x " "openstateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error), __entry->flags,show_fs_fcntl_open_flags (__entry->flags), show_fs_fmode_flags(__entry->fmode),
@@ -943,7 +618,7 @@ TRACE_EVENT(nfs4_close,"error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu " "fhandle=0x%08x openstateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error), __entry->fmode ?show_fs_fmode_flags (__entry->fmode) :"closed" , MAJOR(__entry->dev), MINOR(__entry->dev),
@@ -998,7 +673,7 @@ DECLARE_EVENT_CLASS(nfs4_lock_event,"fileid=%02x:%02x:%llu fhandle=0x%08x " "stateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),show_fs_fcntl_cmd (__entry->cmd),show_fs_fcntl_lock_type (__entry->type), (long long)__entry->start,
@@ -1074,7 +749,7 @@ TRACE_EVENT(nfs4_set_lock,"fileid=%02x:%02x:%llu fhandle=0x%08x " "stateid=%d:0x%08x lockstateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),show_fs_fcntl_cmd (__entry->cmd),show_fs_fcntl_lock_type (__entry->type), (long long)__entry->start,
@@ -1240,7 +915,7 @@ TRACE_EVENT(nfs4_delegreturn_exit,"error=%ld (%s) dev=%02x:%02x fhandle=0x%08x " "stateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), __entry->fhandle, __entry->stateid_seq, __entry->stateid_hash
@@ -1283,7 +958,7 @@ DECLARE_EVENT_CLASS(nfs4_test_stateid_event,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "stateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1330,7 +1005,7 @@ DECLARE_EVENT_CLASS(nfs4_lookup_event,TP_printk ("error=%ld (%s) name=%02x:%02x:%llu/%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->dir, __get_str(name)
@@ -1377,7 +1052,7 @@ TRACE_EVENT(nfs4_lookupp,TP_printk ("error=%ld (%s) inode=%02x:%02x:%llu" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->ino )
@@ -1416,7 +1091,7 @@ TRACE_EVENT(nfs4_rename,"error=%ld (%s) oldname=%02x:%02x:%llu/%s " "newname=%02x:%02x:%llu/%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->olddir, __get_str(oldname),
@@ -1451,7 +1126,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_event,TP_printk ("error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle
@@ -1509,7 +1184,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_stateid_event,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "stateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1562,7 +1237,7 @@ DECLARE_EVENT_CLASS(nfs4_getattr_event,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "valid=%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1618,7 +1293,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_callback_event,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "dstaddr=%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1679,7 +1354,7 @@ DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "stateid=%d:0x%08x dstaddr=%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1728,7 +1403,7 @@ DECLARE_EVENT_CLASS(nfs4_idmap_event,TP_printk ("error=%ld (%s) id=%u name=%s" , - -__entry->error,show_nfsv4_errors (__entry->error), + -__entry->error,show_nfs4_status (__entry->error), __entry->id,__get_str (name) )
@@ -1806,7 +1481,7 @@ DECLARE_EVENT_CLASS(nfs4_read_event,"offset=%lld count=%u res=%u stateid=%d:0x%08x " "layoutstateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1880,7 +1555,7 @@ DECLARE_EVENT_CLASS(nfs4_write_event,"offset=%lld count=%u res=%u stateid=%d:0x%08x " "layoutstateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1944,7 +1619,7 @@ DECLARE_EVENT_CLASS(nfs4_commit_event,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "offset=%lld count=%u layoutstateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -1964,16 +1639,6 @@ DEFINE_NFS4_COMMIT_EVENT(nfs4_commit);#ifdef CONFIG_NFS_V4_1 DEFINE_NFS4_COMMIT_EVENT (nfs4_pnfs_commit_ds); -TRACE_DEFINE_ENUM (IOMODE_READ ); -TRACE_DEFINE_ENUM (IOMODE_RW ); -TRACE_DEFINE_ENUM (IOMODE_ANY ); - -#define show_pnfs_iomode (iomode) \ - __print_symbolic(iomode, \ - { IOMODE_READ, "READ" }, \ - { IOMODE_RW, "RW" }, \ - { IOMODE_ANY, "ANY" }) - TRACE_EVENT(nfs4_layoutget, TP_PROTO( const struct nfs_open_context *ctx,
@@ -2029,11 +1694,11 @@ TRACE_EVENT(nfs4_layoutget,"iomode=%s offset=%llu count=%llu stateid=%d:0x%08x " "layoutstateid=%d:0x%08x" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle, -show_pnfs_iomode (__entry->iomode), +show_pnfs_layout_iomode (__entry->iomode), (unsigned long long )__entry->offset, (unsigned long long )__entry->count, __entry->stateid_seq, __entry->stateid_hash,
@@ -2127,7 +1792,7 @@ TRACE_EVENT(pnfs_update_layout,MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle, -show_pnfs_iomode (__entry->iomode), +show_pnfs_layout_iomode (__entry->iomode), (unsigned long long )__entry->pos, (unsigned long long )__entry->count, __entry->layoutstateid_seq, __entry->layoutstateid_hash,
@@ -2181,7 +1846,7 @@ DECLARE_EVENT_CLASS(pnfs_layout_event,MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle, -show_pnfs_iomode (__entry->iomode), +show_pnfs_layout_iomode (__entry->iomode), (unsigned long long )__entry->pos, (unsigned long long )__entry->count, __entry->layoutstateid_seq, __entry->layoutstateid_hash,
@@ -2326,7 +1991,7 @@ DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
@@ -2382,7 +2047,7 @@ TRACE_EVENT(ff_layout_commit_error,"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " "offset=%llu count=%u dstaddr=%s" , -__entry->error, -show_nfsv4_errors (__entry->error), +show_nfs4_status (__entry->error),MAJOR (__entry->dev),MINOR (__entry->dev), (unsigned long long )__entry->fileid, __entry->fhandle,
fs/nfs/nfstrace.h +19 -98
231 lines not on this page · raw message
fs/nfs/pnfs.h +0 -4
@@ -82,10 +82,6 @@ enum pnfs_try_status { PNFS_TRY_AGAIN = 2, }; -/* error codes for internal use */ -#define NFS4ERR_RESET_TO_MDS 12001 -#define NFS4ERR_RESET_TO_PNFS 12002 -#ifdef CONFIG_NFS_V4_1 #define LAYOUT_NFSV4_1_MODULE_PREFIX "nfs-layouttype4"
fs/nfsd/trace.h +1 -0
@@ -9,6 +9,7 @@#define _NFSD_TRACE_H#include <linux/tracepoint.h> +#include "export.h" #include "nfsfh.h"
include/linux/nfs4.h +4 -0
@@ -292,6 +292,10 @@ enum nfsstat4 { NFS4ERR_XATTR2BIG = 10096, }; +/* error codes for internal client use */ +#define NFS4ERR_RESET_TO_MDS 12001 +#define NFS4ERR_RESET_TO_PNFS 12002 +static inline bool seqid_mutating_err (u32 err) {/* See RFC 7530, section 9.1.7 */
include/trace/events/nfs.h new file +375 -0
375 lines not on this page · raw message
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 199/690 NFSD: Optimize DRC bucket pruning
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit 8847ecc9274a14114385d1cb4030326baa0766eb ]
DRC bucket pruning is done by nfsd_cache_lookup(), which is part of every NFSv2 and NFSv3 dispatch (ie, it's done while the client is waiting).
I added a trace_printk() in prune_bucket() to see just how long it takes to prune. Here are two ends of the spectrum:
prune_bucket: Scanned 1 and freed 0 in 90 ns, 62 entries remaining
prune_bucket: Scanned 2 and freed 1 in 716 ns, 63 entries remaining
...
prune_bucket: Scanned 75 and freed 74 in 34149 ns, 1 entries remaining
Pruning latency is noticeable on fast transports with fast storage. By noticeable, I mean that the latency measured here in the worst case is the same order of magnitude as the round trip time for cached server operations.
We could do something like moving expired entries to an expired list and then free them later instead of freeing them right in prune_bucket(). But simply limiting the number of entries that can be pruned by a lookup is simple and retains more entries in the cache, making the DRC somewhat more effective.
Comparison with a 70/30 fio 8KB 12 thread direct I/O test:
Before:
write: IOPS=61.6k, BW=481MiB/s (505MB/s)(14.1GiB/30001msec); 0 zone resets
WRITE:
1848726 ops (30%)
avg bytes sent per op: 8340 avg bytes received per op: 136
backlog wait: 0.635158 RTT: 0.128525 total execute time: 0.827242 (milliseconds)After:
write: IOPS=63.0k, BW=492MiB/s (516MB/s)(14.4GiB/30001msec); 0 zone resets
WRITE:
1891144 ops (30%)
avg bytes sent per op: 8340 avg bytes received per op: 136
backlog wait: 0.616114 RTT: 0.126842 total execute time: 0.805348 (milliseconds)--- fs/nfsd/nfscache.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)
fs/nfsd/nfscache.c +11 -6
@@ -241,8 +241,8 @@ lru_put_end(struct nfsd_drc_bucket *b, struct svc_cacherep *rp)list_move_tail (&rp->c_lru, &b->lru_head); } -static long -prune_bucket (struct nfsd_drc_bucket *b,struct nfsd_net *nn) +static long prune_bucket (struct nfsd_drc_bucket *b,struct nfsd_net *nn, +unsigned int max) {struct svc_cacherep *rp, *tmp;long freed =0 ;
@@ -258,11 +258,17 @@ prune_bucket(struct nfsd_drc_bucket *b, struct nfsd_net *nn) time_before(jiffies, rp->c_timestamp + RC_EXPIRE)) break;nfsd_reply_cache_free_locked (b, rp, nn); - freed++; +if (max && freed++ > max) +break ; }return freed; } +static long nfsd_prune_bucket (struct nfsd_drc_bucket *b,struct nfsd_net *nn) +{ +return prune_bucket (b, nn,3 ); +} +/* * Walk the LRU list and prune off entries that are older than RC_EXPIRE. * Also prune the oldest ones when the total exceeds the max number of entries.
@@ -279,7 +285,7 @@ prune_cache_entries(struct nfsd_net *nn)if (list_empty (&b->lru_head))continue ;spin_lock (&b->cache_lock); - freed +=prune_bucket (b, nn); + freed +=prune_bucket (b, nn,0 );spin_unlock (&b->cache_lock); }return freed;
@@ -453,8 +459,7 @@ int nfsd_cache_lookup(struct svc_rqst *rqstp)atomic_inc (&nn->num_drc_entries);nfsd_stats_drc_mem_usage_add (nn,sizeof (*rp)); -/* go ahead and prune the cache */ -prune_bucket (b, nn); +nfsd_prune_bucket (b, nn); out_unlock:spin_unlock (&b->cache_lock);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 200/690 NFSD: move filehandle format declarations out of "uapi".
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: NeilBrown <[email protected]>
[ Upstream commit ef5825e3cf0d0af657f5fb4dd86d750ed42fee0a ]
A small part of the declaration concerning filehandle format are currently in the "uapi" include directory:
include/uapi/linux/nfsd/nfsfh.h
There is a lot more to the filehandle format, including "enum fid_type" and "enum nfsd_fsid" which are not exported via "uapi".
This small part of the filehandle definition is of minimal use outside of the kernel, and I can find no evidence that an other code is using it. Certainly nfs-utils and wireshark (The most likely candidates) do not use these declarations.
So move it out of "uapi" by copying the content from
include/uapi/linux/nfsd/nfsfh.h
into
fs/nfsd/nfsfh.h
A few unnecessary "#include" directives are not copied, and neither is the #define of fh_auth, which is annotated as being for userspace only.
The copyright claims in the uapi file are identical to those in the nfsd file, so there is no need to copy those.
The "__u32" style integer types are only needed in "uapi". In kernel-only code we can use the more familiar "u32" style.
--- fs/nfsd/nfsfh.h | 97 ++++++++++++++++++++++++++- fs/nfsd/vfs.c | 1 + include/uapi/linux/nfsd/nfsfh.h | 115 -------------------------------- 3 files changed, 97 insertions(+), 116 deletions(-) delete mode 100644 include/uapi/linux/nfsd/nfsfh.h
fs/nfsd/nfsfh.h +96 -1
@@ -10,9 +10,104 @@#include <linux/crc32.h> #include <linux/sunrpc/svc.h> -#include <uapi/linux/nfsd/nfsfh.h> #include <linux/iversion.h> #include <linux/exportfs.h> +#include <linux/nfs4.h> + + +/* +* This is the old "dentry style" Linux NFSv2 file handle. +* +* The xino and xdev fields are currently used to transport the +* ino/dev of the exported inode. +*/ +struct nfs_fhbase_old { +u32 fb_dcookie;/* dentry cookie - always 0xfeebbaca */ +u32 fb_ino;/* our inode number */ +u32 fb_dirino;/* dir inode number, 0 for directories */ +u32 fb_dev;/* our device */ +u32 fb_xdev; +u32 fb_xino; +u32 fb_generation; +}; + +/* +* This is the new flexible, extensible style NFSv2/v3/v4 file handle. +* +* The file handle starts with a sequence of four-byte words. +* The first word contains a version number (1) and three descriptor bytes +* that tell how the remaining 3 variable length fields should be handled. +* These three bytes are auth_type, fsid_type and fileid_type. +* +* All four-byte values are in host-byte-order. +* +* The auth_type field is deprecated and must be set to 0. +* +* The fsid_type identifies how the filesystem (or export point) is +* encoded. +* Current values: +* 0 - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number +* NOTE: we cannot use the kdev_t device id value, because kdev_t.h +* says we mustn't. We must break it up and reassemble. +* 1 - 4 byte user specified identifier +* 2 - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED +* 3 - 4 byte device id, encoded for user-space, 4 byte inode number +* 4 - 4 byte inode number and 4 byte uuid +* 5 - 8 byte uuid +* 6 - 16 byte uuid +* 7 - 8 byte inode number and 16 byte uuid +* +* The fileid_type identified how the file within the filesystem is encoded. +* The values for this field are filesystem specific, exccept that +* filesystems must not use the values '0' or '0xff'. 'See enum fid_type' +* in include/linux/exportfs.h for currently registered values. +*/ +struct nfs_fhbase_new { +union { +struct { +u8 fb_version_aux;/* == 1, even => nfs_fhbase_old */ +u8 fb_auth_type_aux; +u8 fb_fsid_type_aux; +u8 fb_fileid_type_aux; +u32 fb_auth[1 ]; +/* u32 fb_fsid[0]; floating */ +/* u32 fb_fileid[0]; floating */ + }; +struct { +u8 fb_version;/* == 1, even => nfs_fhbase_old */ +u8 fb_auth_type; +u8 fb_fsid_type; +u8 fb_fileid_type; +u32 fb_auth_flex[];/* flexible-array member */ + }; + }; +}; + +struct knfsd_fh { +unsigned int fh_size;/* significant for NFSv3. +* Points to the current size while building +* a new file handle +*/ +union { +struct nfs_fhbase_old fh_old; +u32 fh_pad[NFS4_FHSIZE /4 ]; +struct nfs_fhbase_new fh_new; + } fh_base; +}; + +#define ofh_dcookie fh_base.fh_old.fb_dcookie +#define ofh_ino fh_base.fh_old.fb_ino +#define ofh_dirino fh_base.fh_old.fb_dirino +#define ofh_dev fh_base.fh_old.fb_dev +#define ofh_xdev fh_base.fh_old.fb_xdev +#define ofh_xino fh_base.fh_old.fb_xino +#define ofh_generation fh_base.fh_old.fb_generation + +#define fh_version fh_base.fh_new.fb_version +#define fh_fsid_type fh_base.fh_new.fb_fsid_type +#define fh_auth_type fh_base.fh_new.fb_auth_type +#define fh_fileid_type fh_base.fh_new.fb_fileid_type +#define fh_fsid fh_base.fh_new.fb_auth_flexstatic inline __u32 ino_t_to_u32 (ino_t ino) {
fs/nfsd/vfs.c +1 -0
@@ -244,6 +244,7 @@ nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,* returned. Otherwise the covered directory is returned. * NOTE: this mountpoint crossing is not supported properly by all * clients and is explicitly disallowed for NFSv3 +* NeilBrown <[email protected]> */ __be32 nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
include/uapi/linux/nfsd/nfsfh.h deleted +0 -115
115 lines not on this page · raw message
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 201/690 NFSD: drop support for ancient filehandles
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: NeilBrown <[email protected]>
[ Upstream commit c645a883df34ee10b884ec921e850def54b7f461 ]
Filehandles not in the "new" or "version 1" format have not been handed out for new mounts since Linux 2.4 which was released 20 years ago. I think it is safe to say that no such file handles are still in use, and that we can drop support for them.
--- fs/nfsd/nfsfh.c | 160 +++++++++++++++--------------------------------- fs/nfsd/nfsfh.h | 34 +--------- 2 files changed, 54 insertions(+), 140 deletions(-)
fs/nfsd/nfsfh.c +51 -109
@@ -154,11 +154,12 @@ static inline __be32 check_pseudo_root(struct svc_rqst *rqstp,static __be32 nfsd_set_fh_dentry (struct svc_rqst *rqstp,struct svc_fh *fhp) {struct knfsd_fh *fh = &fhp->fh_handle; -struct fid *fid =NULL , sfid; +struct fid *fid =NULL ;struct svc_export *exp;struct dentry *dentry;int fileid_type;int data_left = fh->fh_size/4 ; +int len;__be32 error; error = nfserr_stale;
@@ -167,48 +168,35 @@ static __be32 nfsd_set_fh_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp)if (rqstp->rq_vers ==4 && fh->fh_size ==0 )return nfserr_nofilehandle; -if (fh->fh_version ==1 ) { -int len; - -if (--data_left <0 ) -return error; -if (fh->fh_auth_type !=0 ) -return error; - len =key_len (fh->fh_fsid_type) /4 ; -if (len ==0 ) -return error; -if (fh->fh_fsid_type ==FSID_MAJOR_MINOR ) { -/* deprecated, convert to type 3 */ - len =key_len (FSID_ENCODE_DEV )/4 ; - fh->fh_fsid_type =FSID_ENCODE_DEV ; -/* -* struct knfsd_fh uses host-endian fields, which are -* sometimes used to hold net-endian values. This -* confuses sparse, so we must use __force here to -* keep it from complaining. -*/ - fh->fh_fsid[0 ] =new_encode_dev (MKDEV (ntohl ((__force __be32 )fh->fh_fsid[0 ]), -ntohl ((__force __be32 )fh->fh_fsid[1 ]))); - fh->fh_fsid[1 ] = fh->fh_fsid[2 ]; - } - data_left -= len; -if (data_left <0 ) -return error; - exp =rqst_exp_find (rqstp, fh->fh_fsid_type, fh->fh_fsid); - fid = (struct fid *)(fh->fh_fsid + len); - }else { -__u32 tfh[2 ]; -dev_t xdev; -ino_t xino; - -if (fh->fh_size !=NFS_FHSIZE ) -return error; -/* assume old filehandle format */ - xdev =old_decode_dev (fh->ofh_xdev); - xino =u32_to_ino_t (fh->ofh_xino); -mk_fsid (FSID_DEV , tfh, xdev, xino,0 ,NULL ); - exp =rqst_exp_find (rqstp,FSID_DEV , tfh); +if (fh->fh_version !=1 ) +return error; + +if (--data_left <0 ) +return error; +if (fh->fh_auth_type !=0 ) +return error; + len =key_len (fh->fh_fsid_type) /4 ; +if (len ==0 ) +return error; +if (fh->fh_fsid_type ==FSID_MAJOR_MINOR ) { +/* deprecated, convert to type 3 */ + len =key_len (FSID_ENCODE_DEV )/4 ; + fh->fh_fsid_type =FSID_ENCODE_DEV ; +/* +* struct knfsd_fh uses host-endian fields, which are +* sometimes used to hold net-endian values. This +* confuses sparse, so we must use __force here to +* keep it from complaining. +*/ + fh->fh_fsid[0 ] =new_encode_dev (MKDEV (ntohl ((__force __be32 )fh->fh_fsid[0 ]), +ntohl ((__force __be32 )fh->fh_fsid[1 ]))); + fh->fh_fsid[1 ] = fh->fh_fsid[2 ]; } + data_left -= len; +if (data_left <0 ) +return error; + exp =rqst_exp_find (rqstp, fh->fh_fsid_type, fh->fh_fsid); + fid = (struct fid *)(fh->fh_fsid + len); error = nfserr_stale;if (IS_ERR (exp)) {
@@ -253,18 +241,7 @@ static __be32 nfsd_set_fh_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp)if (rqstp->rq_vers >2 ) error = nfserr_badhandle; -if (fh->fh_version !=1 ) { - sfid.i32.ino = fh->ofh_ino; - sfid.i32.gen = fh->ofh_generation; - sfid.i32.parent_ino = fh->ofh_dirino; - fid = &sfid; - data_left =3 ; -if (fh->ofh_dirino ==0 ) - fileid_type =FILEID_INO32_GEN ; -else - fileid_type =FILEID_INO32_GEN_PARENT ; - }else - fileid_type = fh->fh_fileid_type; + fileid_type = fh->fh_fileid_type;if (fileid_type ==FILEID_ROOT ) dentry =dget (exp->ex_path.dentry);
@@ -452,20 +429,6 @@ static void _fh_update(struct svc_fh *fhp, struct svc_export *exp, } } -/* -* for composing old style file handles -*/ -static inline void _fh_update_old (struct dentry *dentry, -struct svc_export *exp, -struct knfsd_fh *fh) -{ - fh->ofh_ino =ino_t_to_u32 (d_inode (dentry)->i_ino); - fh->ofh_generation =d_inode (dentry)->i_generation; -if (d_is_dir (dentry) || - (exp->ex_flags &NFSEXP_NOSUBTREECHECK )) - fh->ofh_dirino =0 ; -} -static bool is_root_export (struct svc_export *exp) {return exp->ex_path.dentry == exp->ex_path.dentry->d_sb->s_root;
@@ -562,9 +525,6 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,/* ref_fh is a reference file handle. * if it is non-null and for the same filesystem, then we should compose * a filehandle which is of the same version, where possible. -* Currently, that means that if ref_fh->fh_handle.fh_version == 0xca -* Then create a 32byte filehandle using nfs_fhbase_old -* */ struct inode * inode =d_inode (dentry);
@@ -600,35 +560,21 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry, fhp->fh_dentry =dget (dentry);/* our internal copy */ fhp->fh_export =exp_get (exp); -if (fhp->fh_handle.fh_version ==0xca ) { -/* old style filehandle please */ -memset (&fhp->fh_handle.fh_base,0 ,NFS_FHSIZE ); - fhp->fh_handle.fh_size =NFS_FHSIZE ; - fhp->fh_handle.ofh_dcookie =0xfeebbaca ; - fhp->fh_handle.ofh_dev =old_encode_dev (ex_dev); - fhp->fh_handle.ofh_xdev = fhp->fh_handle.ofh_dev; - fhp->fh_handle.ofh_xino = -ino_t_to_u32 (d_inode (exp->ex_path.dentry)->i_ino); - fhp->fh_handle.ofh_dirino =ino_t_to_u32 (parent_ino (dentry)); -if (inode) -_fh_update_old (dentry, exp, &fhp->fh_handle); - }else { - fhp->fh_handle.fh_size = -key_len (fhp->fh_handle.fh_fsid_type) +4 ; - fhp->fh_handle.fh_auth_type =0 ; - -mk_fsid (fhp->fh_handle.fh_fsid_type, - fhp->fh_handle.fh_fsid, - ex_dev, -d_inode (exp->ex_path.dentry)->i_ino, - exp->ex_fsid, exp->ex_uuid); - -if (inode) -_fh_update (fhp, exp, dentry); -if (fhp->fh_handle.fh_fileid_type ==FILEID_INVALID ) { -fh_put (fhp); -return nfserr_opnotsupp; - } + fhp->fh_handle.fh_size = +key_len (fhp->fh_handle.fh_fsid_type) +4 ; + fhp->fh_handle.fh_auth_type =0 ; + +mk_fsid (fhp->fh_handle.fh_fsid_type, + fhp->fh_handle.fh_fsid, + ex_dev, +d_inode (exp->ex_path.dentry)->i_ino, + exp->ex_fsid, exp->ex_uuid); + +if (inode) +_fh_update (fhp, exp, dentry); +if (fhp->fh_handle.fh_fileid_type ==FILEID_INVALID ) { +fh_put (fhp); +return nfserr_opnotsupp; }return 0 ;
@@ -649,16 +595,12 @@ fh_update(struct svc_fh *fhp) dentry = fhp->fh_dentry;if (d_really_is_negative (dentry)) goto out_negative; -if (fhp->fh_handle.fh_version !=1 ) { -_fh_update_old (dentry, fhp->fh_export, &fhp->fh_handle); - }else { -if (fhp->fh_handle.fh_fileid_type !=FILEID_ROOT ) -return 0 ; +if (fhp->fh_handle.fh_fileid_type !=FILEID_ROOT ) +return 0 ; -_fh_update (fhp, fhp->fh_export, dentry); -if (fhp->fh_handle.fh_fileid_type ==FILEID_INVALID ) -return nfserr_opnotsupp; - } +_fh_update (fhp, fhp->fh_export, dentry); +if (fhp->fh_handle.fh_fileid_type ==FILEID_INVALID ) +return nfserr_opnotsupp;return 0 ; out_bad:printk (KERN_ERR "fh_update: fh not verified!\n" );
fs/nfsd/nfsfh.h +3 -31
@@ -14,26 +14,7 @@#include <linux/exportfs.h> #include <linux/nfs4.h> - -/* -* This is the old "dentry style" Linux NFSv2 file handle. -* -* The xino and xdev fields are currently used to transport the -* ino/dev of the exported inode. -*/ -struct nfs_fhbase_old { -u32 fb_dcookie;/* dentry cookie - always 0xfeebbaca */ -u32 fb_ino;/* our inode number */ -u32 fb_dirino;/* dir inode number, 0 for directories */ -u32 fb_dev;/* our device */ -u32 fb_xdev; -u32 fb_xino; -u32 fb_generation; -}; -/* -* This is the new flexible, extensible style NFSv2/v3/v4 file handle. -* * The file handle starts with a sequence of four-byte words. * The first word contains a version number (1) and three descriptor bytes * that tell how the remaining 3 variable length fields should be handled.
@@ -57,7 +38,7 @@ struct nfs_fhbase_old {* 6 - 16 byte uuid * 7 - 8 byte inode number and 16 byte uuid * -* The fileid_type identified how the file within the filesystem is encoded. +* The fileid_type identifies how the file within the filesystem is encoded. * The values for this field are filesystem specific, exccept that * filesystems must not use the values '0' or '0xff'. 'See enum fid_type' * in include/linux/exportfs.h for currently registered values.
@@ -65,7 +46,7 @@ struct nfs_fhbase_old { struct nfs_fhbase_new { union { struct { - u8 fb_version_aux; /* == 1, even => nfs_fhbase_old */ + u8 fb_version_aux; /* == 1 */ u8 fb_auth_type_aux; u8 fb_fsid_type_aux; u8 fb_fileid_type_aux;
@@ -74,7 +55,7 @@ struct nfs_fhbase_new {/* u32 fb_fileid[0]; floating */ };struct { -u8 fb_version;/* == 1, even => nfs_fhbase_old */ +u8 fb_version;/* == 1 */ u8 fb_auth_type;u8 fb_fsid_type;u8 fb_fileid_type;
@@ -89,20 +70,11 @@ struct knfsd_fh {* a new file handle */ union { -struct nfs_fhbase_old fh_old;u32 fh_pad[NFS4_FHSIZE /4 ];struct nfs_fhbase_new fh_new; } fh_base; }; -#define ofh_dcookie fh_base.fh_old.fb_dcookie -#define ofh_ino fh_base.fh_old.fb_ino -#define ofh_dirino fh_base.fh_old.fb_dirino -#define ofh_dev fh_base.fh_old.fb_dev -#define ofh_xdev fh_base.fh_old.fb_xdev -#define ofh_xino fh_base.fh_old.fb_xino -#define ofh_generation fh_base.fh_old.fb_generation -#define fh_version fh_base.fh_new.fb_version#define fh_fsid_type fh_base.fh_new.fb_fsid_type#define fh_auth_type fh_base.fh_new.fb_auth_type
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 202/690 NFSD: simplify struct nfsfh
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: NeilBrown <[email protected]>
[ Upstream commit d8b26071e65e80a348602b939e333242f989221b ]
Most of the fields in 'struct knfsd_fh' are 2 levels deep (a union and a struct) and are accessed using macros like:
#define fh_FOO fh_base.fh_new.fb_FOO
This patch makes the union and struct anonymous, so that "fh_FOO" can be a name directly within 'struct knfsd_fh' and the #defines aren't needed.
The file handle as a whole is sometimes accessed as "fh_base" or "fh_base.fh_pad", neither of which are particularly helpful names. As the struct holding the filehandle is now anonymous, we cannot use the name of that, so we union it with 'fh_raw' and use that where the raw filehandle is needed. fh_raw also ensure the structure is large enough for the largest possible filehandle.
fh_raw is a 'char' array, removing any need to cast it for memcpy etc.
SVCFH_fmt() is simplified using the "%ph" printk format. This changes the appearance of filehandles in dprintk() debugging, making them a little more precise.
--- fs/nfsd/flexfilelayout.c | 2 +- fs/nfsd/lockd.c | 2 +- fs/nfsd/nfs3xdr.c | 4 ++-- fs/nfsd/nfs4callback.c | 2 +- fs/nfsd/nfs4proc.c | 4 ++-- fs/nfsd/nfs4state.c | 4 ++-- fs/nfsd/nfs4xdr.c | 4 ++-- fs/nfsd/nfsctl.c | 6 ++--- fs/nfsd/nfsfh.c | 13 ++++------- fs/nfsd/nfsfh.h | 50 ++++++++++++---------------------------- fs/nfsd/nfsxdr.c | 4 ++-- 11 files changed, 35 insertions(+), 60 deletions(-)
fs/nfsd/flexfilelayout.c +1 -1
@@ -61,7 +61,7 @@ nfsd4_ff_proc_layoutget(struct inode *inode, const struct svc_fh *fhp, goto out_error; fl->fh.size = fhp->fh_handle.fh_size; -memcpy (fl->fh.data, &fhp->fh_handle.fh_base, fl->fh.size); +memcpy (fl->fh.data, &fhp->fh_handle.fh_raw, fl->fh.size);/* Give whole file layout segments */ seg->offset =0 ;
fs/nfsd/lockd.c +1 -1
@@ -35,7 +35,7 @@ nlm_fopen(struct svc_rqst *rqstp, struct nfs_fh *f, struct file **filp,/* must initialize before using! but maxsize doesn't matter */ fh_init (&fh,0 ); fh.fh_handle.fh_size = f->size; -memcpy ((char *)&fh.fh_handle.fh_base, f->data, f->size); +memcpy (&fh.fh_handle.fh_raw, f->data, f->size); fh.fh_export =NULL ; access = (mode ==O_WRONLY ) ?NFSD_MAY_WRITE :NFSD_MAY_READ ;
fs/nfsd/nfs3xdr.c +2 -2
@@ -92,7 +92,7 @@ svcxdr_decode_nfs_fh3(struct xdr_stream *xdr, struct svc_fh *fhp)return false;fh_init (fhp,NFS3_FHSIZE ); fhp->fh_handle.fh_size = size; -memcpy (&fhp->fh_handle.fh_base, p, size); +memcpy (&fhp->fh_handle.fh_raw, p, size);return true; }
@@ -131,7 +131,7 @@ svcxdr_encode_nfs_fh3(struct xdr_stream *xdr, const struct svc_fh *fhp) *p++ =cpu_to_be32 (size);if (size) p[XDR_QUADLEN (size) -1 ] =0 ; -memcpy (p, &fhp->fh_handle.fh_base, size); +memcpy (p, &fhp->fh_handle.fh_raw, size);return true; }
fs/nfsd/nfs4callback.c +1 -1
@@ -121,7 +121,7 @@ static void encode_nfs_fh4(struct xdr_stream *xdr, const struct knfsd_fh *fh)BUG_ON (length >NFS4_FHSIZE ); p =xdr_reserve_space (xdr,4 + length); -xdr_encode_opaque (p, &fh->fh_base, length); +xdr_encode_opaque (p, &fh->fh_raw, length); }/*
fs/nfsd/nfs4proc.c +2 -2
@@ -519,7 +519,7 @@ nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,fh_put (&cstate->current_fh); cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; -memcpy (&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval, +memcpy (&cstate->current_fh.fh_handle.fh_raw, putfh->pf_fhval, putfh->pf_fhlen); ret =fh_verify (rqstp, &cstate->current_fh,0 ,NFSD_MAY_BYPASS_GSS );#ifdef CONFIG_NFSD_V4_2_INTER_SSC
@@ -1383,7 +1383,7 @@ nfsd4_setup_inter_ssc(struct svc_rqst *rqstp, s_fh = &cstate->save_fh; copy->c_fh.size = s_fh->fh_handle.fh_size; -memcpy (copy->c_fh.data, &s_fh->fh_handle.fh_base, copy->c_fh.size); +memcpy (copy->c_fh.data, &s_fh->fh_handle.fh_raw, copy->c_fh.size); copy->stateid.seqid =cpu_to_be32 (s_stid->si_generation);memcpy (copy->stateid.other, (void *)&s_stid->si_opaque,sizeof (stateid_opaque_t));
fs/nfsd/nfs4state.c +2 -2
@@ -1022,7 +1022,7 @@ static int delegation_blocked(struct knfsd_fh *fh) }spin_unlock (&blocked_delegations_lock); } - hash =jhash (&fh->fh_base, fh->fh_size,0 ); + hash =jhash (&fh->fh_raw, fh->fh_size,0 );if (test_bit (hash&255 , bd->set[0 ]) &&test_bit ((hash>>8 )&255 , bd->set[0 ]) &&test_bit ((hash>>16 )&255 , bd->set[0 ]))
@@ -1041,7 +1041,7 @@ static void block_delegations(struct knfsd_fh *fh)u32 hash;struct bloom_pair *bd = &blocked_delegations; - hash =jhash (&fh->fh_base, fh->fh_size,0 ); + hash =jhash (&fh->fh_raw, fh->fh_size,0 );spin_lock (&blocked_delegations_lock);__set_bit (hash&255 , bd->set[bd->new]);
fs/nfsd/nfs4xdr.c +2 -2
@@ -3104,7 +3104,7 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, p =xdr_reserve_space (xdr, fhp->fh_handle.fh_size +4 );if (!p) goto out_resource; - p =xdr_encode_opaque (p, &fhp->fh_handle.fh_base, + p =xdr_encode_opaque (p, &fhp->fh_handle.fh_raw, fhp->fh_handle.fh_size); }if (bmval0 &FATTR4_WORD0_FILEID ) {
@@ -3675,7 +3675,7 @@ nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh p =xdr_reserve_space (xdr, len +4 );if (!p)return nfserr_resource; - p =xdr_encode_opaque (p, &fhp->fh_handle.fh_base, len); + p =xdr_encode_opaque (p, &fhp->fh_handle.fh_raw, len);return 0 ; }
fs/nfsd/nfsctl.c +3 -3
@@ -395,12 +395,12 @@ static ssize_t write_filehandle(struct file *file, char *buf, size_t size)auth_domain_put (dom);if (len)return len; - + mesg = buf; len =SIMPLE_TRANSACTION_LIMIT ; -qword_addhex (&mesg, &len, (char *)&fh.fh_base, fh.fh_size); +qword_addhex (&mesg, &len, fh.fh_raw, fh.fh_size); mesg[-1 ] ='\n' ; -return mesg - buf; +return mesg - buf; }/*
fs/nfsd/nfsfh.c +4 -9
@@ -640,16 +640,11 @@ fh_put(struct svc_fh *fhp)char *SVCFH_fmt (struct svc_fh *fhp) {struct knfsd_fh *fh = &fhp->fh_handle; +static char buf[2 +1 +1 +64 *3 +1 ]; -static char buf[80 ]; -sprintf (buf,"%d: %08x %08x %08x %08x %08x %08x" , - fh->fh_size, - fh->fh_base.fh_pad[0 ], - fh->fh_base.fh_pad[1 ], - fh->fh_base.fh_pad[2 ], - fh->fh_base.fh_pad[3 ], - fh->fh_base.fh_pad[4 ], - fh->fh_base.fh_pad[5 ]); +if (fh->fh_size <0 || fh->fh_size>64 ) +return "bad-fh" ; +sprintf (buf,"%d: %*ph" , fh->fh_size, fh->fh_size, fh->fh_raw);return buf; }
fs/nfsd/nfsfh.h +15 -35
80 lines not on this page · raw message
fs/nfsd/nfsxdr.c +2 -2
@@ -64,7 +64,7 @@ svcxdr_decode_fhandle(struct xdr_stream *xdr, struct svc_fh *fhp)if (!p)return false;fh_init (fhp,NFS_FHSIZE ); -memcpy (&fhp->fh_handle.fh_base, p,NFS_FHSIZE ); +memcpy (&fhp->fh_handle.fh_raw, p,NFS_FHSIZE ); fhp->fh_handle.fh_size =NFS_FHSIZE ;return true;
@@ -78,7 +78,7 @@ svcxdr_encode_fhandle(struct xdr_stream *xdr, const struct svc_fh *fhp) p =xdr_reserve_space (xdr,NFS_FHSIZE );if (!p)return false; -memcpy (p, &fhp->fh_handle.fh_base,NFS_FHSIZE ); +memcpy (p, &fhp->fh_handle.fh_raw,NFS_FHSIZE );return true; }
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 203/690 NFSD: Initialize pointer ni with NULL and not plain integer 0
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Colin Ian King <[email protected]>
[ Upstream commit 8e70bf27fd20cc17e87150327a640e546bfbee64 ]
Pointer ni is being initialized with plain integer zero. Fix this by initializing with NULL.
--- fs/nfsd/nfs4proc.c | 2 +- fs/nfsd/nfs4state.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
fs/nfsd/nfs4proc.c +1 -1
@@ -1184,7 +1184,7 @@ extern void nfs_sb_deactive(struct super_block *sb);static __be32 nfsd4_ssc_setup_dul (struct nfsd_net *nn,char *ipaddr,struct nfsd4_ssc_umount_item **retwork,struct vfsmount **ss_mnt) { -struct nfsd4_ssc_umount_item *ni =0 ; +struct nfsd4_ssc_umount_item *ni =NULL ;struct nfsd4_ssc_umount_item *work =NULL ;struct nfsd4_ssc_umount_item *tmp;DEFINE_WAIT (wait);
fs/nfsd/nfs4state.c +1 -1
@@ -5573,7 +5573,7 @@ static void nfsd4_ssc_shutdown_umount(struct nfsd_net *nn)static void nfsd4_ssc_expire_umount (struct nfsd_net *nn) {bool do_wakeup = false; -struct nfsd4_ssc_umount_item *ni =0 ; +struct nfsd4_ssc_umount_item *ni =NULL ;struct nfsd4_ssc_umount_item *tmp;spin_lock (&nn->nfsd_ssc_lock);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 204/690 SUNRPC: Replace the "__be32 *p" parameter to .pc_decode
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit 16c663642c7ec03cd4cee5fec520bb69e97babe4 ]
The passed-in value of the "__be32 *p" parameter is now unused in every server-side XDR decoder, and can be removed.
Note also that there is a line in each decoder that sets up a local pointer to a struct xdr_stream. Passing that pointer from the dispatcher instead saves one line per decoder function.
--- fs/lockd/svc.c | 3 +-- fs/lockd/xdr.c | 27 +++++++++-------------- fs/lockd/xdr4.c | 27 +++++++++-------------- fs/nfsd/nfs2acl.c | 12 +++++----- fs/nfsd/nfs3acl.c | 8 +++---- fs/nfsd/nfs3xdr.c | 45 +++++++++++++------------------------- fs/nfsd/nfs4xdr.c | 4 ++-- fs/nfsd/nfsd.h | 3 ++- fs/nfsd/nfssvc.c | 7 +++--- fs/nfsd/nfsxdr.c | 30 +++++++++---------------- fs/nfsd/xdr.h | 21 +++++++++--------- fs/nfsd/xdr3.h | 31 +++++++++++++------------- fs/nfsd/xdr4.h | 2 +- include/linux/lockd/xdr.h | 19 ++++++++-------- include/linux/lockd/xdr4.h | 21 +++++++++--------- include/linux/sunrpc/svc.h | 3 ++- 16 files changed, 113 insertions(+), 150 deletions(-)
fs/lockd/svc.c +1 -2
@@ -780,11 +780,10 @@ module_exit(exit_nlm);static int nlmsvc_dispatch (struct svc_rqst *rqstp,__be32 *statp) {const struct svc_procedure *procp = rqstp->rq_procinfo; -struct kvec *argv = rqstp->rq_arg.head;struct kvec *resv = rqstp->rq_res.head;svcxdr_init_decode (rqstp); -if (!procp->pc_decode (rqstp, argv->iov_base)) +if (!procp->pc_decode (rqstp, &rqstp->rq_arg_stream)) goto out_decode_err; *statp = procp->pc_func (rqstp);
fs/lockd/xdr.c +10 -17
@@ -146,15 +146,14 @@ svcxdr_encode_testrply(struct xdr_stream *xdr, const struct nlm_res *resp)*/ int -nlmsvc_decode_void (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) {return 1 ; }int -nlmsvc_decode_testargs (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;
@@ -171,9 +170,8 @@ nlmsvc_decode_testargs(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_decode_lockargs (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;
@@ -197,9 +195,8 @@ nlmsvc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_decode_cancargs (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;
@@ -218,9 +215,8 @@ nlmsvc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_decode_unlockargs (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;if (!svcxdr_decode_cookie (xdr, &argp->cookie))
@@ -233,9 +229,8 @@ nlmsvc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_decode_res (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_res *resp = rqstp->rq_argp;if (!svcxdr_decode_cookie (xdr, &resp->cookie))
@@ -247,10 +242,10 @@ nlmsvc_decode_res(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_decode_reboot (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_reboot *argp = rqstp->rq_argp; +__be32 *p;u32 len;if (xdr_stream_decode_u32 (xdr, &len) <0 )
@@ -273,9 +268,8 @@ nlmsvc_decode_reboot(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_decode_shareargs (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;struct nlm_lock *lock = &argp->lock;
@@ -301,9 +295,8 @@ nlmsvc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_decode_notify (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;struct nlm_lock *lock = &argp->lock;
fs/lockd/xdr4.c +10 -17
@@ -141,15 +141,14 @@ svcxdr_encode_testrply(struct xdr_stream *xdr, const struct nlm_res *resp)*/ int -nlm4svc_decode_void (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) {return 1 ; }int -nlm4svc_decode_testargs (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;
@@ -166,9 +165,8 @@ nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_decode_lockargs (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;
@@ -192,9 +190,8 @@ nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_decode_cancargs (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;
@@ -212,9 +209,8 @@ nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_decode_unlockargs (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;if (!svcxdr_decode_cookie (xdr, &argp->cookie))
@@ -227,9 +223,8 @@ nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_decode_res (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_res *resp = rqstp->rq_argp;if (!svcxdr_decode_cookie (xdr, &resp->cookie))
@@ -241,10 +236,10 @@ nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_decode_reboot (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_reboot *argp = rqstp->rq_argp; +__be32 *p;u32 len;if (xdr_stream_decode_u32 (xdr, &len) <0 )
@@ -267,9 +262,8 @@ nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_decode_shareargs (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;struct nlm_lock *lock = &argp->lock;
@@ -295,9 +289,8 @@ nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_decode_notify (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nlm_args *argp = rqstp->rq_argp;struct nlm_lock *lock = &argp->lock;
fs/nfsd/nfs2acl.c +6 -6
@@ -188,9 +188,9 @@ static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)* XDR decode functions */ -static int nfsaclsvc_decode_getaclargs (struct svc_rqst *rqstp,__be32 *p) +static int +nfsaclsvc_decode_getaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd3_getaclargs *argp = rqstp->rq_argp;if (!svcxdr_decode_fhandle (xdr, &argp->fh))
@@ -201,9 +201,9 @@ static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)return 1 ; } -static int nfsaclsvc_decode_setaclargs (struct svc_rqst *rqstp,__be32 *p) +static int +nfsaclsvc_decode_setaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd3_setaclargs *argp = rqstp->rq_argp;if (!svcxdr_decode_fhandle (xdr, &argp->fh))
@@ -222,9 +222,9 @@ static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p)return 1 ; } -static int nfsaclsvc_decode_accessargs (struct svc_rqst *rqstp,__be32 *p) +static int +nfsaclsvc_decode_accessargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd3_accessargs *args = rqstp->rq_argp;if (!svcxdr_decode_fhandle (xdr, &args->fh))
fs/nfsd/nfs3acl.c +4 -4
@@ -127,9 +127,9 @@ static __be32 nfsd3_proc_setacl(struct svc_rqst *rqstp)* XDR decode functions */ -static int nfs3svc_decode_getaclargs (struct svc_rqst *rqstp,__be32 *p) +static int +nfs3svc_decode_getaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd3_getaclargs *args = rqstp->rq_argp;if (!svcxdr_decode_nfs_fh3 (xdr, &args->fh))
@@ -140,9 +140,9 @@ static int nfs3svc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)return 1 ; } -static int nfs3svc_decode_setaclargs (struct svc_rqst *rqstp,__be32 *p) +static int +nfs3svc_decode_setaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd3_setaclargs *argp = rqstp->rq_argp;if (!svcxdr_decode_nfs_fh3 (xdr, &argp->fh))
fs/nfsd/nfs3xdr.c +15 -30
150 lines not on this page · raw message
fs/nfsd/nfs4xdr.c +2 -2
@@ -5413,14 +5413,14 @@ void nfsd4_release_compoundargs(struct svc_rqst *rqstp) }int -nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,__be32 *p) +nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd4_compoundargs *args = rqstp->rq_argp;/* svcxdr_tmp_alloc */ args->to_free =NULL ; - args->xdr = &rqstp->rq_arg_stream; + args->xdr = xdr; args->ops = args->iops; args->rqstp = rqstp;
fs/nfsd/nfsd.h +2 -1
@@ -78,7 +78,8 @@ extern const struct seq_operations nfs_exports_op;*/ struct nfsd_voidargs { };struct nfsd_voidres { }; -int nfssvc_decode_voidarg (struct svc_rqst *rqstp,__be32 *p); +int nfssvc_decode_voidarg (struct svc_rqst *rqstp, +struct xdr_stream *xdr);int nfssvc_encode_voidres (struct svc_rqst *rqstp,__be32 *p);/*
fs/nfsd/nfssvc.c +3 -4
@@ -1004,7 +1004,6 @@ nfsd(void *vrqstp)int nfsd_dispatch (struct svc_rqst *rqstp,__be32 *statp) {const struct svc_procedure *proc = rqstp->rq_procinfo; -struct kvec *argv = &rqstp->rq_arg.head[0 ];struct kvec *resv = &rqstp->rq_res.head[0 ];__be32 *p;
@@ -1015,7 +1014,7 @@ int nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp) rqstp->rq_cachetype = proc->pc_cachetype;svcxdr_init_decode (rqstp); -if (!proc->pc_decode (rqstp, argv->iov_base)) +if (!proc->pc_decode (rqstp, &rqstp->rq_arg_stream)) goto out_decode_err;switch (nfsd_cache_lookup (rqstp)) {
@@ -1065,13 +1064,13 @@ int nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)/** * nfssvc_decode_voidarg - Decode void arguments * @rqstp: Server RPC transaction context -* @p: buffer containing arguments to decode +* @xdr: XDR stream positioned at arguments to decode * * Return values: * %0: Arguments were not valid * %1: Decoding was successful */ -int nfssvc_decode_voidarg (struct svc_rqst *rqstp,__be32 *p) +int nfssvc_decode_voidarg (struct svc_rqst *rqstp,struct xdr_stream *xdr) {return 1 ; }
fs/nfsd/nfsxdr.c +10 -20
@@ -273,18 +273,16 @@ svcxdr_encode_fattr(struct svc_rqst *rqstp, struct xdr_stream *xdr,*/ int -nfssvc_decode_fhandleargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_fhandleargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_fhandle *args = rqstp->rq_argp;return svcxdr_decode_fhandle (xdr, &args->fh); }int -nfssvc_decode_sattrargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_sattrargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_sattrargs *args = rqstp->rq_argp; return svcxdr_decode_fhandle(xdr, &args->fh) &&
@@ -292,18 +290,16 @@ nfssvc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_decode_diropargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_diropargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_diropargs *args = rqstp->rq_argp;return svcxdr_decode_diropargs (xdr, &args->fh, &args->name, &args->len); }int -nfssvc_decode_readargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_readargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_readargs *args = rqstp->rq_argp;u32 totalcount;
@@ -321,9 +317,8 @@ nfssvc_decode_readargs(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_decode_writeargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_writeargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_writeargs *args = rqstp->rq_argp;u32 beginoffset, totalcount;
@@ -350,9 +345,8 @@ nfssvc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_decode_createargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_createargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_createargs *args = rqstp->rq_argp; return svcxdr_decode_diropargs(xdr, &args->fh,
@@ -361,9 +355,8 @@ nfssvc_decode_createargs(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_decode_renameargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_renameargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_renameargs *args = rqstp->rq_argp; return svcxdr_decode_diropargs(xdr, &args->ffh,
@@ -373,9 +366,8 @@ nfssvc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_decode_linkargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_linkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_linkargs *args = rqstp->rq_argp; return svcxdr_decode_fhandle(xdr, &args->ffh) &&
@@ -384,9 +376,8 @@ nfssvc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_decode_symlinkargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_symlinkargs *args = rqstp->rq_argp;struct kvec *head = rqstp->rq_arg.head;
@@ -405,9 +396,8 @@ nfssvc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_decode_readdirargs (struct svc_rqst *rqstp,__be32 *p) +nfssvc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_arg_stream;struct nfsd_readdirargs *args = rqstp->rq_argp;if (!svcxdr_decode_fhandle (xdr, &args->fh))
fs/nfsd/xdr.h +11 -10
@@ -141,16 +141,17 @@ union nfsd_xdrstore {#define NFS2_SVC_XDRSIZE sizeof(union nfsd_xdrstore) -int nfssvc_decode_fhandleargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_sattrargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_diropargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_readargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_writeargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_createargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_renameargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_linkargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_symlinkargs (struct svc_rqst *,__be32 *); -int nfssvc_decode_readdirargs (struct svc_rqst *,__be32 *); +int nfssvc_decode_fhandleargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_sattrargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_diropargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_readargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_writeargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_createargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_renameargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_linkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_encode_statres (struct svc_rqst *,__be32 *);int nfssvc_encode_attrstatres (struct svc_rqst *,__be32 *);int nfssvc_encode_diropres (struct svc_rqst *,__be32 *);
fs/nfsd/xdr3.h +16 -15
@@ -265,21 +265,22 @@ union nfsd3_xdrstore {#define NFS3_SVC_XDRSIZE sizeof(union nfsd3_xdrstore) -int nfs3svc_decode_fhandleargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_sattrargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_diropargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_accessargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_readargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_writeargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_createargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_mkdirargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_mknodargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_renameargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_linkargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_symlinkargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_readdirargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_readdirplusargs (struct svc_rqst *,__be32 *); -int nfs3svc_decode_commitargs (struct svc_rqst *,__be32 *); +int nfs3svc_decode_fhandleargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_sattrargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_diropargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_accessargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_readargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_writeargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_createargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_mkdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_mknodargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_renameargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_linkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_readdirplusargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_decode_commitargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_getattrres (struct svc_rqst *,__be32 *);int nfs3svc_encode_wccstat (struct svc_rqst *,__be32 *);int nfs3svc_encode_lookupres (struct svc_rqst *,__be32 *);
fs/nfsd/xdr4.h +1 -1
@@ -757,7 +757,7 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)bool nfsd4_mach_creds_match (struct nfs4_client *cl,struct svc_rqst *rqstp); -int nfs4svc_decode_compoundargs (struct svc_rqst *,__be32 *); +int nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);int nfs4svc_encode_compoundres (struct svc_rqst *,__be32 *);__be32 nfsd4_check_resp_size (struct nfsd4_compoundres *,u32 );void nfsd4_encode_operation (struct nfsd4_compoundres *,struct nfsd4_op *);
include/linux/lockd/xdr.h +10 -9
@@ -98,18 +98,19 @@ struct nlm_reboot {*/ #define NLMSVC_XDRSIZE sizeof(struct nlm_args) -int nlmsvc_decode_testargs (struct svc_rqst *,__be32 *); +int nlmsvc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_encode_testres (struct svc_rqst *,__be32 *); -int nlmsvc_decode_lockargs (struct svc_rqst *,__be32 *); -int nlmsvc_decode_cancargs (struct svc_rqst *,__be32 *); -int nlmsvc_decode_unlockargs (struct svc_rqst *,__be32 *);int nlmsvc_encode_res (struct svc_rqst *,__be32 *); -int nlmsvc_decode_res (struct svc_rqst *,__be32 *);int nlmsvc_encode_void (struct svc_rqst *,__be32 *); -int nlmsvc_decode_void (struct svc_rqst *,__be32 *); -int nlmsvc_decode_shareargs (struct svc_rqst *,__be32 *);int nlmsvc_encode_shareres (struct svc_rqst *,__be32 *); -int nlmsvc_decode_notify (struct svc_rqst *,__be32 *); -int nlmsvc_decode_reboot (struct svc_rqst *,__be32 *);#endif /* LOCKD_XDR_H */
include/linux/lockd/xdr4.h +10 -11
@@ -22,22 +22,21 @@#define nlm4_fbig cpu_to_be32(NLM_FBIG)#define nlm4_failed cpu_to_be32(NLM_FAILED) - -void nlm4svc_set_file_lock_range (struct file_lock *fl,u64 off,u64 len); -int nlm4svc_decode_testargs (struct svc_rqst *,__be32 *); +int nlm4svc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_encode_testres (struct svc_rqst *,__be32 *); -int nlm4svc_decode_lockargs (struct svc_rqst *,__be32 *); -int nlm4svc_decode_cancargs (struct svc_rqst *,__be32 *); -int nlm4svc_decode_unlockargs (struct svc_rqst *,__be32 *);int nlm4svc_encode_res (struct svc_rqst *,__be32 *); -int nlm4svc_decode_res (struct svc_rqst *,__be32 *);int nlm4svc_encode_void (struct svc_rqst *,__be32 *); -int nlm4svc_decode_void (struct svc_rqst *,__be32 *); -int nlm4svc_decode_shareargs (struct svc_rqst *,__be32 *);int nlm4svc_encode_shareres (struct svc_rqst *,__be32 *); -int nlm4svc_decode_notify (struct svc_rqst *,__be32 *); -int nlm4svc_decode_reboot (struct svc_rqst *,__be32 *);extern const struct rpc_version nlm_version4;
include/linux/sunrpc/svc.h +2 -1
@@ -456,7 +456,8 @@ struct svc_procedure {/* process the request: */ __be32 (*pc_func)(struct svc_rqst *);/* XDR decode args: */ -int (*pc_decode)(struct svc_rqst *,__be32 *data); +int (*pc_decode)(struct svc_rqst *rqstp, +struct xdr_stream *xdr);/* XDR encode result: */ int (*pc_encode)(struct svc_rqst *,__be32 *data);/* XDR free result: */
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 205/690 SUNRPC: Change return value type of .pc_decode
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit c44b31c263798ec34614dd394c31ef1a2e7e716e ]
Returning an undecorated integer is an age-old trope, but it's not clear (even to previous experts in this code) that the only valid return values are 1 and 0. These functions do not return a negative errno, rpc_stat value, or a positive length.
Document there are only two valid return values by having .pc_decode return only true or false.
--- fs/lockd/xdr.c | 96 +++++++++++++++--------------- fs/lockd/xdr4.c | 97 +++++++++++++++--------------- fs/nfsd/nfs2acl.c | 30 +++++----- fs/nfsd/nfs3acl.c | 22 +++---- fs/nfsd/nfs3xdr.c | 118 ++++++++++++++++++------------------- fs/nfsd/nfs4xdr.c | 22 +++---- fs/nfsd/nfsd.h | 2 +- fs/nfsd/nfssvc.c | 6 +- fs/nfsd/nfsxdr.c | 62 +++++++++---------- fs/nfsd/xdr.h | 20 +++---- fs/nfsd/xdr3.h | 30 +++++----- fs/nfsd/xdr4.h | 2 +- include/linux/lockd/xdr.h | 18 +++--- include/linux/lockd/xdr4.h | 18 +++--- include/linux/sunrpc/svc.h | 2 +- 15 files changed, 273 insertions(+), 272 deletions(-)
fs/lockd/xdr.c +48 -48
@@ -145,103 +145,103 @@ svcxdr_encode_testrply(struct xdr_stream *xdr, const struct nlm_res *resp)* Decode Call arguments */ -int +bool nlmsvc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -return 1 ; +return true; } -int +bool nlmsvc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;if (!svcxdr_decode_cookie (xdr, &argp->cookie)) -return 0 ; +return false;if (xdr_stream_decode_bool (xdr, &exclusive) <0 ) -return 0 ; +return false;if (!svcxdr_decode_lock (xdr, &argp->lock)) -return 0 ; +return false;if (exclusive) argp->lock.fl.fl_type =F_WRLCK ; -return 1 ; +return true; } -int +bool nlmsvc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;if (!svcxdr_decode_cookie (xdr, &argp->cookie)) -return 0 ; +return false;if (xdr_stream_decode_bool (xdr, &argp->block) <0 ) -return 0 ; +return false;if (xdr_stream_decode_bool (xdr, &exclusive) <0 ) -return 0 ; +return false;if (!svcxdr_decode_lock (xdr, &argp->lock)) -return 0 ; +return false;if (exclusive) argp->lock.fl.fl_type =F_WRLCK ;if (xdr_stream_decode_bool (xdr, &argp->reclaim) <0 ) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &argp->state) <0 ) -return 0 ; +return false; argp->monitor =1 ;/* monitor client by default */ -return 1 ; +return true; } -int +bool nlmsvc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_args *argp = rqstp->rq_argp;u32 exclusive;if (!svcxdr_decode_cookie (xdr, &argp->cookie)) -return 0 ; +return false;if (xdr_stream_decode_bool (xdr, &argp->block) <0 ) -return 0 ; +return false;if (xdr_stream_decode_bool (xdr, &exclusive) <0 ) -return 0 ; +return false;if (!svcxdr_decode_lock (xdr, &argp->lock)) -return 0 ; +return false;if (exclusive) argp->lock.fl.fl_type =F_WRLCK ; -return 1 ; +return true; } -int +bool nlmsvc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_args *argp = rqstp->rq_argp;if (!svcxdr_decode_cookie (xdr, &argp->cookie)) -return 0 ; +return false;if (!svcxdr_decode_lock (xdr, &argp->lock)) -return 0 ; +return false; argp->lock.fl.fl_type =F_UNLCK ; -return 1 ; +return true; } -int +bool nlmsvc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_res *resp = rqstp->rq_argp;if (!svcxdr_decode_cookie (xdr, &resp->cookie)) -return 0 ; +return false;if (!svcxdr_decode_stats (xdr, &resp->status)) -return 0 ; +return false; -return 1 ; +return true; } -int +bool nlmsvc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_reboot *argp = rqstp->rq_argp;
@@ -249,25 +249,25 @@ nlmsvc_decode_reboot(struct svc_rqst *rqstp, struct xdr_stream *xdr)u32 len;if (xdr_stream_decode_u32 (xdr, &len) <0 ) -return 0 ; +return false;if (len >SM_MAXSTRLEN ) -return 0 ; +return false; p =xdr_inline_decode (xdr, len);if (!p) -return 0 ; +return false; argp->len = len; argp->mon = (char *)p;if (xdr_stream_decode_u32 (xdr, &argp->state) <0 ) -return 0 ; +return false; p =xdr_inline_decode (xdr,SM_PRIV_SIZE );if (!p) -return 0 ; +return false;memcpy (&argp->priv.data, p,sizeof (argp->priv.data)); -return 1 ; +return true; } -int +bool nlmsvc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_args *argp = rqstp->rq_argp;
@@ -278,34 +278,34 @@ nlmsvc_decode_shareargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) lock->svid = ~(u32 )0 ;if (!svcxdr_decode_cookie (xdr, &argp->cookie)) -return 0 ; +return false;if (!svcxdr_decode_string (xdr, &lock->caller, &lock->len)) -return 0 ; +return false;if (!svcxdr_decode_fhandle (xdr, &lock->fh)) -return 0 ; +return false;if (!svcxdr_decode_owner (xdr, &lock->oh)) -return 0 ; +return false;/* XXX: Range checks are missing in the original code */ if (xdr_stream_decode_u32 (xdr, &argp->fsm_mode) <0 ) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &argp->fsm_access) <0 ) -return 0 ; +return false; -return 1 ; +return true; } -int +bool nlmsvc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_args *argp = rqstp->rq_argp;struct nlm_lock *lock = &argp->lock;if (!svcxdr_decode_string (xdr, &lock->caller, &lock->len)) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &argp->state) <0 ) -return 0 ; +return false; -return 1 ; +return true; }
fs/lockd/xdr4.c +49 -48
210 lines not on this page · raw message
fs/nfsd/nfs2acl.c +15 -15
@@ -188,51 +188,51 @@ static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)* XDR decode functions */ -static int +static bool nfsaclsvc_decode_getaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_getaclargs *argp = rqstp->rq_argp;if (!svcxdr_decode_fhandle (xdr, &argp->fh)) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &argp->mask) <0 ) -return 0 ; +return false; -return 1 ; +return true; } -static int +static bool nfsaclsvc_decode_setaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_setaclargs *argp = rqstp->rq_argp;if (!svcxdr_decode_fhandle (xdr, &argp->fh)) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &argp->mask) <0 ) -return 0 ; +return false;if (argp->mask & ~NFS_ACL_MASK ) -return 0 ; +return false;if (!nfs_stream_decode_acl (xdr,NULL , (argp->mask &NFS_ACL ) ? &argp->acl_access :NULL )) -return 0 ; +return false;if (!nfs_stream_decode_acl (xdr,NULL , (argp->mask &NFS_DFACL ) ? &argp->acl_default :NULL )) -return 0 ; +return false; -return 1 ; +return true; } -static int +static bool nfsaclsvc_decode_accessargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_accessargs *args = rqstp->rq_argp;if (!svcxdr_decode_fhandle (xdr, &args->fh)) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &args->access) <0 ) -return 0 ; +return false; -return 1 ; +return true; }/*
fs/nfsd/nfs3acl.c +11 -11
@@ -127,38 +127,38 @@ static __be32 nfsd3_proc_setacl(struct svc_rqst *rqstp)* XDR decode functions */ -static int +static bool nfs3svc_decode_getaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_getaclargs *args = rqstp->rq_argp;if (!svcxdr_decode_nfs_fh3 (xdr, &args->fh)) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &args->mask) <0 ) -return 0 ; +return false; -return 1 ; +return true; } -static int +static bool nfs3svc_decode_setaclargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_setaclargs *argp = rqstp->rq_argp;if (!svcxdr_decode_nfs_fh3 (xdr, &argp->fh)) -return 0 ; +return false;if (xdr_stream_decode_u32 (xdr, &argp->mask) <0 ) -return 0 ; +return false;if (argp->mask & ~NFS_ACL_MASK ) -return 0 ; +return false;if (!nfs_stream_decode_acl (xdr,NULL , (argp->mask &NFS_ACL ) ? &argp->acl_access :NULL )) -return 0 ; +return false;if (!nfs_stream_decode_acl (xdr,NULL , (argp->mask &NFS_DFACL ) ? &argp->acl_default :NULL )) -return 0 ; +return false; -return 1 ; +return true; }/*
fs/nfsd/nfs3xdr.c +59 -59
289 lines not on this page · raw message
fs/nfsd/nfs4xdr.c +11 -11
@@ -2319,7 +2319,7 @@ nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op)return true; } -static int +static bool nfsd4_decode_compound (struct nfsd4_compoundargs *argp) {struct nfsd4_op *op;
@@ -2332,25 +2332,25 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)int i;if (xdr_stream_decode_u32 (argp->xdr, &argp->taglen) <0 ) -return 0 ; +return false; max_reply +=XDR_UNIT ; argp->tag =NULL ;if (unlikely (argp->taglen)) {if (argp->taglen >NFSD4_MAX_TAGLEN ) -return 0 ; +return false; p =xdr_inline_decode (argp->xdr, argp->taglen);if (!p) -return 0 ; +return false; argp->tag =svcxdr_savemem (argp, p, argp->taglen);if (!argp->tag) -return 0 ; +return false; max_reply +=xdr_align_size (argp->taglen); }if (xdr_stream_decode_u32 (argp->xdr, &argp->minorversion) <0 ) -return 0 ; +return false;if (xdr_stream_decode_u32 (argp->xdr, &argp->client_opcnt) <0 ) -return 0 ; +return false; argp->opcnt =min_t (u32, argp->client_opcnt,NFSD_MAX_OPS_PER_COMPOUND );
@@ -2360,7 +2360,7 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)if (!argp->ops) { argp->ops = argp->iops;dprintk ("nfsd: couldn't allocate room for COMPOUND\n" ); -return 0 ; +return false; } }
@@ -2373,7 +2373,7 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp) op->opdesc =NULL ;if (xdr_stream_decode_u32 (argp->xdr, &op->opnum) <0 ) -return 0 ; +return false;if (nfsd4_opnum_in_range (argp, op)) { op->opdesc =OPDESC (op); op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
@@ -2421,7 +2421,7 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)if (readcount >1 || max_reply >PAGE_SIZE - auth_slack)clear_bit (RQ_SPLICE_OK , &argp->rqstp->rq_flags); -return 1 ; +return true; } static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode,
@@ -5412,7 +5412,7 @@ void nfsd4_release_compoundargs(struct svc_rqst *rqstp) } } -int +bool nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd4_compoundargs *args = rqstp->rq_argp;
fs/nfsd/nfsd.h +1 -1
@@ -78,7 +78,7 @@ extern const struct seq_operations nfs_exports_op;*/ struct nfsd_voidargs { };struct nfsd_voidres { }; -int nfssvc_decode_voidarg (struct svc_rqst *rqstp, +bool nfssvc_decode_voidarg (struct svc_rqst *rqstp,struct xdr_stream *xdr);int nfssvc_encode_voidres (struct svc_rqst *rqstp,__be32 *p);
fs/nfsd/nfssvc.c +3 -3
@@ -1067,10 +1067,10 @@ int nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)* @xdr: XDR stream positioned at arguments to decode * * Return values: -* %0: Arguments were not valid -* %1: Decoding was successful +* %false: Arguments were not valid +* %true: Decoding was successful */ -int nfssvc_decode_voidarg (struct svc_rqst *rqstp,struct xdr_stream *xdr) +bool nfssvc_decode_voidarg (struct svc_rqst *rqstp,struct xdr_stream *xdr) {return 1 ; }
fs/nfsd/nfsxdr.c +31 -31
159 lines not on this page · raw message
fs/nfsd/xdr.h +10 -10
@@ -141,16 +141,16 @@ union nfsd_xdrstore {#define NFS2_SVC_XDRSIZE sizeof(union nfsd_xdrstore) -int nfssvc_decode_fhandleargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_sattrargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_diropargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_readargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_writeargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_createargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_renameargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_linkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_fhandleargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_sattrargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_diropargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_readargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_writeargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_createargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_renameargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_linkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);int nfssvc_encode_statres (struct svc_rqst *,__be32 *);int nfssvc_encode_attrstatres (struct svc_rqst *,__be32 *);
fs/nfsd/xdr3.h +15 -15
@@ -265,21 +265,21 @@ union nfsd3_xdrstore {#define NFS3_SVC_XDRSIZE sizeof(union nfsd3_xdrstore) -int nfs3svc_decode_fhandleargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_sattrargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_diropargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_accessargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_readargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_writeargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_createargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_mkdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_mknodargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_renameargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_linkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_readdirplusargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_decode_commitargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_fhandleargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_sattrargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_diropargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_accessargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_readargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_writeargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_createargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_mkdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_mknodargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_renameargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_linkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_readdirplusargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_decode_commitargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);int nfs3svc_encode_getattrres (struct svc_rqst *,__be32 *);int nfs3svc_encode_wccstat (struct svc_rqst *,__be32 *);
fs/nfsd/xdr4.h +1 -1
@@ -757,7 +757,7 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)bool nfsd4_mach_creds_match (struct nfs4_client *cl,struct svc_rqst *rqstp); -int nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);int nfs4svc_encode_compoundres (struct svc_rqst *,__be32 *);__be32 nfsd4_check_resp_size (struct nfsd4_compoundres *,u32 );void nfsd4_encode_operation (struct nfsd4_compoundres *,struct nfsd4_op *);
include/linux/lockd/xdr.h +9 -9
@@ -98,15 +98,15 @@ struct nlm_reboot {*/ #define NLMSVC_XDRSIZE sizeof(struct nlm_args) -int nlmsvc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr);int nlmsvc_encode_testres (struct svc_rqst *,__be32 *);int nlmsvc_encode_res (struct svc_rqst *,__be32 *);
include/linux/lockd/xdr4.h +9 -9
@@ -23,15 +23,15 @@#define nlm4_failed cpu_to_be32(NLM_FAILED)void nlm4svc_set_file_lock_range (struct file_lock *fl,u64 off,u64 len); -int nlm4svc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_testargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_lockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_cancargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_unlockargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_reboot (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr);int nlm4svc_encode_testres (struct svc_rqst *,__be32 *);int nlm4svc_encode_res (struct svc_rqst *,__be32 *);
include/linux/sunrpc/svc.h +1 -1
@@ -456,7 +456,7 @@ struct svc_procedure {/* process the request: */ __be32 (*pc_func)(struct svc_rqst *);/* XDR decode args: */ -int (*pc_decode)(struct svc_rqst *rqstp, +bool (*pc_decode)(struct svc_rqst *rqstp,struct xdr_stream *xdr);/* XDR encode result: */ int (*pc_encode)(struct svc_rqst *,__be32 *data);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 206/690 NFSD: Save location of NFSv4 COMPOUND status
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit 3b0ebb255fdc49a3d340846deebf045ef58ec744 ]
Refactor: Currently nfs4svc_encode_compoundres() relies on the NFS dispatcher to pass in the buffer location of the COMPOUND status. Instead, save that buffer location in struct nfsd4_compoundres.
The compound tag follows immediately after.
--- fs/nfsd/nfs4proc.c | 2 +- fs/nfsd/nfs4xdr.c | 9 +++++++-- fs/nfsd/xdr4.h | 3 ++- 3 files changed, 10 insertions(+), 4 deletions(-)
fs/nfsd/nfs4proc.c +1 -1
@@ -2462,11 +2462,11 @@ nfsd4_proc_compound(struct svc_rqst *rqstp)__be32 status; resp->xdr = &rqstp->rq_res_stream; + resp->statusp = resp->xdr->p;/* reserve space for: NFS status code */ xdr_reserve_space (resp->xdr,XDR_UNIT ); - resp->tagp = resp->xdr->p;/* reserve space for: taglen, tag, and opcnt */ xdr_reserve_space (resp->xdr,XDR_UNIT *2 + args->taglen); resp->taglen = args->taglen;
fs/nfsd/nfs4xdr.c +7 -2
@@ -5436,11 +5436,16 @@ nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p)WARN_ON_ONCE (buf->len != buf->head[0 ].iov_len + buf->page_len + buf->tail[0 ].iov_len); - *p = resp->cstate.status; +/* +* Send buffer space for the following items is reserved +* at the top of nfsd4_proc_compound(). +*/ + p = resp->statusp; + + *p++ = resp->cstate.status; rqstp->rq_next_page = resp->xdr->page_ptr +1 ; - p = resp->tagp; *p++ =htonl (resp->taglen);memcpy (p, resp->tag, resp->taglen); p +=XDR_QUADLEN (resp->taglen);
fs/nfsd/xdr4.h +2 -1
@@ -703,10 +703,11 @@ struct nfsd4_compoundres {struct xdr_stream *xdr;struct svc_rqst * rqstp; +__be32 *statusp;u32 taglen;char * tag;u32 opcnt; -__be32 * tagp;/* tag, opcount encode location */ +struct nfsd4_compound_state cstate; };
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 207/690 SUNRPC: Replace the "__be32 *p" parameter to .pc_encode
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit fda494411485aff91768842c532f90fb8eb54943 ]
The passed-in value of the "__be32 *p" parameter is now unused in every server-side XDR encoder, and can be removed.
Note also that there is a line in each encoder that sets up a local pointer to a struct xdr_stream. Passing that pointer from the dispatcher instead saves one line per encoder function.
--- fs/lockd/svc.c | 3 +-- fs/lockd/xdr.c | 11 ++++----- fs/lockd/xdr4.c | 11 ++++----- fs/nfs/callback_xdr.c | 4 ++-- fs/nfsd/nfs2acl.c | 8 +++---- fs/nfsd/nfs3acl.c | 8 +++---- fs/nfsd/nfs3xdr.c | 46 +++++++++++++------------------------- fs/nfsd/nfs4xdr.c | 7 +++--- fs/nfsd/nfsd.h | 3 ++- fs/nfsd/nfssvc.c | 9 +++----- fs/nfsd/nfsxdr.c | 22 +++++++----------- fs/nfsd/xdr.h | 14 ++++++------ fs/nfsd/xdr3.h | 30 ++++++++++++------------- fs/nfsd/xdr4.h | 2 +- include/linux/lockd/xdr.h | 8 +++---- include/linux/lockd/xdr4.h | 8 +++---- include/linux/sunrpc/svc.h | 3 ++- 17 files changed, 85 insertions(+), 112 deletions(-)
fs/lockd/svc.c +1 -2
@@ -780,7 +780,6 @@ module_exit(exit_nlm);static int nlmsvc_dispatch (struct svc_rqst *rqstp,__be32 *statp) {const struct svc_procedure *procp = rqstp->rq_procinfo; -struct kvec *resv = rqstp->rq_res.head;svcxdr_init_decode (rqstp);if (!procp->pc_decode (rqstp, &rqstp->rq_arg_stream))
@@ -793,7 +792,7 @@ static int nlmsvc_dispatch(struct svc_rqst *rqstp, __be32 *statp)return 1 ;svcxdr_init_encode (rqstp); -if (!procp->pc_encode (rqstp, resv->iov_base + resv->iov_len)) +if (!procp->pc_encode (rqstp, &rqstp->rq_res_stream)) goto out_encode_err;return 1 ;
fs/lockd/xdr.c +4 -7
@@ -314,15 +314,14 @@ nlmsvc_decode_notify(struct svc_rqst *rqstp, struct xdr_stream *xdr)*/ int -nlmsvc_encode_void (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) {return 1 ; }int -nlmsvc_encode_testres (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nlm_res *resp = rqstp->rq_resp; return svcxdr_encode_cookie(xdr, &resp->cookie) &&
@@ -330,9 +329,8 @@ nlmsvc_encode_testres(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_encode_res (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nlm_res *resp = rqstp->rq_resp; return svcxdr_encode_cookie(xdr, &resp->cookie) &&
@@ -340,9 +338,8 @@ nlmsvc_encode_res(struct svc_rqst *rqstp, __be32 *p) }int -nlmsvc_encode_shareres (struct svc_rqst *rqstp,__be32 *p) +nlmsvc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nlm_res *resp = rqstp->rq_resp;if (!svcxdr_encode_cookie (xdr, &resp->cookie))
fs/lockd/xdr4.c +4 -7
@@ -309,15 +309,14 @@ nlm4svc_decode_notify(struct svc_rqst *rqstp, struct xdr_stream *xdr)*/ int -nlm4svc_encode_void (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) {return 1 ; }int -nlm4svc_encode_testres (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nlm_res *resp = rqstp->rq_resp; return svcxdr_encode_cookie(xdr, &resp->cookie) &&
@@ -325,9 +324,8 @@ nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_encode_res (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nlm_res *resp = rqstp->rq_resp; return svcxdr_encode_cookie(xdr, &resp->cookie) &&
@@ -335,9 +333,8 @@ nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p) }int -nlm4svc_encode_shareres (struct svc_rqst *rqstp,__be32 *p) +nlm4svc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nlm_res *resp = rqstp->rq_resp;if (!svcxdr_encode_cookie (xdr, &resp->cookie))
fs/nfs/callback_xdr.c +2 -2
@@ -67,9 +67,9 @@ static __be32 nfs4_callback_null(struct svc_rqst *rqstp)* svc_process_common() looks for an XDR encoder to know when * not to drop a Reply. */ -static int nfs4_encode_void (struct svc_rqst *rqstp,__be32 *p) +static int nfs4_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -return xdr_ressize_check (rqstp, p); +return 1 ; } static __be32 decode_string(struct xdr_stream *xdr, unsigned int *len,
fs/nfsd/nfs2acl.c +4 -4
@@ -240,9 +240,9 @@ nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)*/ /* GETACL */ -static int nfsaclsvc_encode_getaclres (struct svc_rqst *rqstp,__be32 *p) +static int +nfsaclsvc_encode_getaclres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd3_getaclres *resp = rqstp->rq_resp;struct dentry *dentry = resp->fh.fh_dentry;struct inode *inode;
@@ -270,9 +270,9 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p) }/* ACCESS */ -static int nfsaclsvc_encode_accessres (struct svc_rqst *rqstp,__be32 *p) +static int +nfsaclsvc_encode_accessres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd3_accessres *resp = rqstp->rq_resp;if (!svcxdr_encode_stat (xdr, resp->status))
fs/nfsd/nfs3acl.c +4 -4
@@ -166,9 +166,9 @@ nfs3svc_decode_setaclargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)*/ /* GETACL */ -static int nfs3svc_encode_getaclres (struct svc_rqst *rqstp,__be32 *p) +static int +nfs3svc_encode_getaclres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd3_getaclres *resp = rqstp->rq_resp;struct dentry *dentry = resp->fh.fh_dentry;struct kvec *head = rqstp->rq_res.head;
@@ -218,9 +218,9 @@ static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p) }/* SETACL */ -static int nfs3svc_encode_setaclres (struct svc_rqst *rqstp,__be32 *p) +static int +nfs3svc_encode_setaclres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd3_attrstat *resp = rqstp->rq_resp; return svcxdr_encode_nfsstat3(xdr, resp->status) &&
fs/nfsd/nfs3xdr.c +16 -30
151 lines not on this page · raw message
fs/nfsd/nfs4xdr.c +4 -3
@@ -5428,10 +5428,11 @@ nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) }int -nfs4svc_encode_compoundres (struct svc_rqst *rqstp,__be32 *p) +nfs4svc_encode_compoundres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd4_compoundres *resp = rqstp->rq_resp; -struct xdr_buf *buf = resp->xdr->buf; +struct xdr_buf *buf = xdr->buf; +__be32 *p;WARN_ON_ONCE (buf->len != buf->head[0 ].iov_len + buf->page_len + buf->tail[0 ].iov_len);
@@ -5444,7 +5445,7 @@ nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p) *p++ = resp->cstate.status; - rqstp->rq_next_page = resp->xdr->page_ptr +1 ; + rqstp->rq_next_page = xdr->page_ptr +1 ; *p++ =htonl (resp->taglen);memcpy (p, resp->tag, resp->taglen);
fs/nfsd/nfsd.h +2 -1
@@ -80,7 +80,8 @@ struct nfsd_voidargs { };struct nfsd_voidres { };bool nfssvc_decode_voidarg (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_voidres (struct svc_rqst *rqstp,__be32 *p); +int nfssvc_encode_voidres (struct svc_rqst *rqstp, +struct xdr_stream *xdr);/* * Function prototypes.
fs/nfsd/nfssvc.c +3 -6
@@ -1004,8 +1004,6 @@ nfsd(void *vrqstp)int nfsd_dispatch (struct svc_rqst *rqstp,__be32 *statp) {const struct svc_procedure *proc = rqstp->rq_procinfo; -struct kvec *resv = &rqstp->rq_res.head[0 ]; -__be32 *p;/* * Give the xdr decoder a chance to change this if it wants
@@ -1030,14 +1028,13 @@ int nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)* Need to grab the location to store the status, as * NFSv4 does some encoding while processing */ - p = resv->iov_base + resv->iov_len;svcxdr_init_encode (rqstp); *statp = proc->pc_func (rqstp);if (*statp == rpc_drop_reply ||test_bit (RQ_DROPME , &rqstp->rq_flags)) goto out_update_drop; -if (!proc->pc_encode (rqstp, p)) +if (!proc->pc_encode (rqstp, &rqstp->rq_res_stream)) goto out_encode_err;nfsd_cache_update (rqstp, rqstp->rq_cachetype, statp +1 );
@@ -1078,13 +1075,13 @@ bool nfssvc_decode_voidarg(struct svc_rqst *rqstp, struct xdr_stream *xdr)/** * nfssvc_encode_voidres - Encode void results * @rqstp: Server RPC transaction context -* @p: buffer in which to encode results +* @xdr: XDR stream into which to encode results * * Return values: * %0: Local error while encoding * %1: Encoding was successful */ -int nfssvc_encode_voidres (struct svc_rqst *rqstp,__be32 *p) +int nfssvc_encode_voidres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {return 1 ; }
fs/nfsd/nfsxdr.c +8 -14
@@ -415,18 +415,16 @@ nfssvc_decode_readdirargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)*/ int -nfssvc_encode_statres (struct svc_rqst *rqstp,__be32 *p) +nfssvc_encode_statres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd_stat *resp = rqstp->rq_resp;return svcxdr_encode_stat (xdr, resp->status); }int -nfssvc_encode_attrstatres (struct svc_rqst *rqstp,__be32 *p) +nfssvc_encode_attrstatres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd_attrstat *resp = rqstp->rq_resp;if (!svcxdr_encode_stat (xdr, resp->status))
@@ -442,9 +440,8 @@ nfssvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_encode_diropres (struct svc_rqst *rqstp,__be32 *p) +nfssvc_encode_diropres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd_diropres *resp = rqstp->rq_resp;if (!svcxdr_encode_stat (xdr, resp->status))
@@ -462,9 +459,8 @@ nfssvc_encode_diropres(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_encode_readlinkres (struct svc_rqst *rqstp,__be32 *p) +nfssvc_encode_readlinkres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd_readlinkres *resp = rqstp->rq_resp;struct kvec *head = rqstp->rq_res.head;
@@ -484,9 +480,8 @@ nfssvc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_encode_readres (struct svc_rqst *rqstp,__be32 *p) +nfssvc_encode_readres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd_readres *resp = rqstp->rq_resp;struct kvec *head = rqstp->rq_res.head;
@@ -509,9 +504,8 @@ nfssvc_encode_readres(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_encode_readdirres (struct svc_rqst *rqstp,__be32 *p) +nfssvc_encode_readdirres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd_readdirres *resp = rqstp->rq_resp;struct xdr_buf *dirlist = &resp->dirlist;
@@ -532,11 +526,11 @@ nfssvc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p) }int -nfssvc_encode_statfsres (struct svc_rqst *rqstp,__be32 *p) +nfssvc_encode_statfsres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -struct xdr_stream *xdr = &rqstp->rq_res_stream;struct nfsd_statfsres *resp = rqstp->rq_resp;struct kstatfs *stat = &resp->stats; +__be32 *p;if (!svcxdr_encode_stat (xdr, resp->status))return 0 ;
fs/nfsd/xdr.h +7 -7
@@ -152,13 +152,13 @@ bool nfssvc_decode_linkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nfssvc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nfssvc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_statres (struct svc_rqst *,__be32 *); -int nfssvc_encode_attrstatres (struct svc_rqst *,__be32 *); -int nfssvc_encode_diropres (struct svc_rqst *,__be32 *); -int nfssvc_encode_readlinkres (struct svc_rqst *,__be32 *); -int nfssvc_encode_readres (struct svc_rqst *,__be32 *); -int nfssvc_encode_statfsres (struct svc_rqst *,__be32 *); -int nfssvc_encode_readdirres (struct svc_rqst *,__be32 *); +int nfssvc_encode_statres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_encode_attrstatres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_encode_diropres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_encode_readlinkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_encode_readres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_encode_statfsres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfssvc_encode_readdirres (struct svc_rqst *rqstp,struct xdr_stream *xdr);void nfssvc_encode_nfscookie (struct nfsd_readdirres *resp,u32 offset); int nfssvc_encode_entry(void *data, const char *name, int namlen,
fs/nfsd/xdr3.h +15 -15
@@ -281,21 +281,21 @@ bool nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nfs3svc_decode_readdirplusargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nfs3svc_decode_commitargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_getattrres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_wccstat (struct svc_rqst *,__be32 *); -int nfs3svc_encode_lookupres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_accessres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_readlinkres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_readres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_writeres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_createres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_renameres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_linkres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_readdirres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_fsstatres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_fsinfores (struct svc_rqst *,__be32 *); -int nfs3svc_encode_pathconfres (struct svc_rqst *,__be32 *); -int nfs3svc_encode_commitres (struct svc_rqst *,__be32 *); +int nfs3svc_encode_getattrres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_wccstat (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_lookupres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_accessres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_readlinkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_readres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_writeres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_createres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_renameres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_linkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_readdirres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_fsstatres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_fsinfores (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_pathconfres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nfs3svc_encode_commitres (struct svc_rqst *rqstp,struct xdr_stream *xdr);void nfs3svc_release_fhandle (struct svc_rqst *);void nfs3svc_release_fhandle2 (struct svc_rqst *);
fs/nfsd/xdr4.h +1 -1
@@ -759,7 +759,7 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)bool nfsd4_mach_creds_match (struct nfs4_client *cl,struct svc_rqst *rqstp);bool nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs4svc_encode_compoundres (struct svc_rqst *,__be32 *); +int nfs4svc_encode_compoundres (struct svc_rqst *rqstp,struct xdr_stream *xdr);__be32 nfsd4_check_resp_size (struct nfsd4_compoundres *,u32 );void nfsd4_encode_operation (struct nfsd4_compoundres *,struct nfsd4_op *);void nfsd4_encode_replay (struct xdr_stream *xdr,struct nfsd4_op *op);
include/linux/lockd/xdr.h +4 -4
@@ -108,9 +108,9 @@ bool nlmsvc_decode_reboot(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nlmsvc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nlmsvc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_encode_testres (struct svc_rqst *,__be32 *); -int nlmsvc_encode_res (struct svc_rqst *,__be32 *); -int nlmsvc_encode_void (struct svc_rqst *,__be32 *); -int nlmsvc_encode_shareres (struct svc_rqst *,__be32 *); +int nlmsvc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlmsvc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr);#endif /* LOCKD_XDR_H */
include/linux/lockd/xdr4.h +4 -4
@@ -33,10 +33,10 @@ bool nlm4svc_decode_reboot(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nlm4svc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nlm4svc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_encode_testres (struct svc_rqst *,__be32 *); -int nlm4svc_encode_res (struct svc_rqst *,__be32 *); -int nlm4svc_encode_void (struct svc_rqst *,__be32 *); -int nlm4svc_encode_shareres (struct svc_rqst *,__be32 *); +int nlm4svc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +int nlm4svc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr);extern const struct rpc_version nlm_version4;
include/linux/sunrpc/svc.h +2 -1
@@ -459,7 +459,8 @@ struct svc_procedure {bool (*pc_decode)(struct svc_rqst *rqstp,struct xdr_stream *xdr);/* XDR encode result: */ -int (*pc_encode)(struct svc_rqst *,__be32 *data); +int (*pc_encode)(struct svc_rqst *rqstp, +struct xdr_stream *xdr);/* XDR free result: */ void (*pc_release)(struct svc_rqst *);unsigned int pc_argsize;/* argument struct size */
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 208/690 SUNRPC: Change return value type of .pc_encode
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chuck Lever <[email protected]>
[ Upstream commit 130e2054d4a652a2bd79fb1557ddcd19c053cb37 ]
Returning an undecorated integer is an age-old trope, but it's not clear (even to previous experts in this code) that the only valid return values are 1 and 0. These functions do not return a negative errno, rpc_stat value, or a positive length.
Document there are only two valid return values by having .pc_encode return only true or false.
--- fs/lockd/xdr.c | 18 ++-- fs/lockd/xdr4.c | 18 ++-- fs/nfs/callback_xdr.c | 4 +- fs/nfsd/nfs2acl.c | 4 +- fs/nfsd/nfs3acl.c | 18 ++-- fs/nfsd/nfs3xdr.c | 166 ++++++++++++++++++------------------- fs/nfsd/nfs4xdr.c | 4 +- fs/nfsd/nfsd.h | 2 +- fs/nfsd/nfssvc.c | 8 +- fs/nfsd/nfsxdr.c | 60 +++++++------- fs/nfsd/xdr.h | 14 ++-- fs/nfsd/xdr3.h | 30 +++---- fs/nfsd/xdr4.h | 2 +- include/linux/lockd/xdr.h | 8 +- include/linux/lockd/xdr4.h | 8 +- include/linux/sunrpc/svc.h | 2 +- 16 files changed, 183 insertions(+), 183 deletions(-)
fs/lockd/xdr.c +9 -9
@@ -313,13 +313,13 @@ nlmsvc_decode_notify(struct svc_rqst *rqstp, struct xdr_stream *xdr)* Encode Reply results */ -int +bool nlmsvc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -return 1 ; +return true; } -int +bool nlmsvc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_res *resp = rqstp->rq_resp;
@@ -328,7 +328,7 @@ nlmsvc_encode_testres(struct svc_rqst *rqstp, struct xdr_stream *xdr)svcxdr_encode_testrply (xdr, resp); } -int +bool nlmsvc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_res *resp = rqstp->rq_resp;
@@ -337,18 +337,18 @@ nlmsvc_encode_res(struct svc_rqst *rqstp, struct xdr_stream *xdr)svcxdr_encode_stats (xdr, resp->status); } -int +bool nlmsvc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_res *resp = rqstp->rq_resp;if (!svcxdr_encode_cookie (xdr, &resp->cookie)) -return 0 ; +return false;if (!svcxdr_encode_stats (xdr, resp->status)) -return 0 ; +return false;/* sequence */ if (xdr_stream_encode_u32 (xdr,0 ) <0 ) -return 0 ; +return false; -return 1 ; +return true; }
fs/lockd/xdr4.c +9 -9
@@ -308,13 +308,13 @@ nlm4svc_decode_notify(struct svc_rqst *rqstp, struct xdr_stream *xdr)* Encode Reply results */ -int +bool nlm4svc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -return 1 ; +return true; } -int +bool nlm4svc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_res *resp = rqstp->rq_resp;
@@ -323,7 +323,7 @@ nlm4svc_encode_testres(struct svc_rqst *rqstp, struct xdr_stream *xdr)svcxdr_encode_testrply (xdr, resp); } -int +bool nlm4svc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_res *resp = rqstp->rq_resp;
@@ -332,18 +332,18 @@ nlm4svc_encode_res(struct svc_rqst *rqstp, struct xdr_stream *xdr)svcxdr_encode_stats (xdr, resp->status); } -int +bool nlm4svc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nlm_res *resp = rqstp->rq_resp;if (!svcxdr_encode_cookie (xdr, &resp->cookie)) -return 0 ; +return false;if (!svcxdr_encode_stats (xdr, resp->status)) -return 0 ; +return false;/* sequence */ if (xdr_stream_encode_u32 (xdr,0 ) <0 ) -return 0 ; +return false; -return 1 ; +return true; }
fs/nfs/callback_xdr.c +2 -2
@@ -67,9 +67,9 @@ static __be32 nfs4_callback_null(struct svc_rqst *rqstp)* svc_process_common() looks for an XDR encoder to know when * not to drop a Reply. */ -static int nfs4_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) +static bool nfs4_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -return 1 ; +return true; } static __be32 decode_string(struct xdr_stream *xdr, unsigned int *len,
fs/nfsd/nfs2acl.c +2 -2
@@ -240,7 +240,7 @@ nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)*/ /* GETACL */ -static int +static bool nfsaclsvc_encode_getaclres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_getaclres *resp = rqstp->rq_resp;
@@ -270,7 +270,7 @@ nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, struct xdr_stream *xdr) }/* ACCESS */ -static int +static bool nfsaclsvc_encode_accessres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_accessres *resp = rqstp->rq_resp;
fs/nfsd/nfs3acl.c +9 -9
@@ -166,7 +166,7 @@ nfs3svc_decode_setaclargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)*/ /* GETACL */ -static int +static bool nfs3svc_encode_getaclres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_getaclres *resp = rqstp->rq_resp;
@@ -178,14 +178,14 @@ nfs3svc_encode_getaclres(struct svc_rqst *rqstp, struct xdr_stream *xdr)int w;if (!svcxdr_encode_nfsstat3 (xdr, resp->status)) -return 0 ; +return false;switch (resp->status) {case nfs_ok: inode =d_inode (dentry);if (!svcxdr_encode_post_op_attr (rqstp, xdr, &resp->fh)) -return 0 ; +return false;if (xdr_stream_encode_u32 (xdr, resp->mask) <0 ) -return 0 ; +return false; base = (char *)xdr->p - (char *)head->iov_base;
@@ -194,7 +194,7 @@ nfs3svc_encode_getaclres(struct svc_rqst *rqstp, struct xdr_stream *xdr) (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);while (w >0 ) {if (!*(rqstp->rq_next_page++)) -return 0 ; +return false; w -=PAGE_SIZE ; }
@@ -207,18 +207,18 @@ nfs3svc_encode_getaclres(struct svc_rqst *rqstp, struct xdr_stream *xdr) resp->mask &NFS_DFACL , NFS_ACL_DEFAULT);if (n <=0 ) -return 0 ; +return false;break ;default :if (!svcxdr_encode_post_op_attr (rqstp, xdr, &resp->fh)) -return 0 ; +return false; } -return 1 ; +return true; }/* SETACL */ -static int +static bool nfs3svc_encode_setaclres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd3_attrstat *resp = rqstp->rq_resp;
fs/nfsd/nfs3xdr.c +83 -83
416 lines not on this page · raw message
fs/nfsd/nfs4xdr.c +2 -2
@@ -5427,7 +5427,7 @@ nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)return nfsd4_decode_compound (args); } -int +bool nfs4svc_encode_compoundres (struct svc_rqst *rqstp,struct xdr_stream *xdr) {struct nfsd4_compoundres *resp = rqstp->rq_resp;
@@ -5453,5 +5453,5 @@ nfs4svc_encode_compoundres(struct svc_rqst *rqstp, struct xdr_stream *xdr) *p++ =htonl (resp->opcnt);nfsd4_sequence_done (resp); -return 1 ; +return true; }
fs/nfsd/nfsd.h +1 -1
@@ -80,7 +80,7 @@ struct nfsd_voidargs { };struct nfsd_voidres { };bool nfssvc_decode_voidarg (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_voidres (struct svc_rqst *rqstp, +bool nfssvc_encode_voidres (struct svc_rqst *rqstp,struct xdr_stream *xdr);/*
fs/nfsd/nfssvc.c +4 -4
@@ -1078,12 +1078,12 @@ bool nfssvc_decode_voidarg(struct svc_rqst *rqstp, struct xdr_stream *xdr)* @xdr: XDR stream into which to encode results * * Return values: -* %0: Local error while encoding -* %1: Encoding was successful +* %false: Local error while encoding +* %true: Encoding was successful */ -int nfssvc_encode_voidres (struct svc_rqst *rqstp,struct xdr_stream *xdr) +bool nfssvc_encode_voidres (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -return 1 ; +return true; }int nfsd_pool_stats_open (struct inode *inode,struct file *file)
fs/nfsd/nfsxdr.c +30 -30
166 lines not on this page · raw message
fs/nfsd/xdr.h +7 -7
@@ -152,13 +152,13 @@ bool nfssvc_decode_linkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nfssvc_decode_symlinkargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nfssvc_decode_readdirargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_statres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_attrstatres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_diropres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_readlinkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_readres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_statfsres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfssvc_encode_readdirres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_encode_statres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_encode_attrstatres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_encode_diropres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_encode_readlinkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_encode_readres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_encode_statfsres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfssvc_encode_readdirres (struct svc_rqst *rqstp,struct xdr_stream *xdr);void nfssvc_encode_nfscookie (struct nfsd_readdirres *resp,u32 offset); int nfssvc_encode_entry(void *data, const char *name, int namlen,
fs/nfsd/xdr3.h +15 -15
@@ -281,21 +281,21 @@ bool nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nfs3svc_decode_readdirplusargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nfs3svc_decode_commitargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_getattrres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_wccstat (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_lookupres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_accessres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_readlinkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_readres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_writeres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_createres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_renameres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_linkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_readdirres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_fsstatres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_fsinfores (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_pathconfres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs3svc_encode_commitres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_getattrres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_wccstat (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_lookupres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_accessres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_readlinkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_readres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_writeres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_createres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_renameres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_linkres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_readdirres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_fsstatres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_fsinfores (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_pathconfres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs3svc_encode_commitres (struct svc_rqst *rqstp,struct xdr_stream *xdr);void nfs3svc_release_fhandle (struct svc_rqst *);void nfs3svc_release_fhandle2 (struct svc_rqst *);
fs/nfsd/xdr4.h +1 -1
@@ -759,7 +759,7 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)bool nfsd4_mach_creds_match (struct nfs4_client *cl,struct svc_rqst *rqstp);bool nfs4svc_decode_compoundargs (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nfs4svc_encode_compoundres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nfs4svc_encode_compoundres (struct svc_rqst *rqstp,struct xdr_stream *xdr);__be32 nfsd4_check_resp_size (struct nfsd4_compoundres *,u32 );void nfsd4_encode_operation (struct nfsd4_compoundres *,struct nfsd4_op *);void nfsd4_encode_replay (struct xdr_stream *xdr,struct nfsd4_op *op);
include/linux/lockd/xdr.h +4 -4
@@ -108,9 +108,9 @@ bool nlmsvc_decode_reboot(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nlmsvc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nlmsvc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlmsvc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlmsvc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr);#endif /* LOCKD_XDR_H */
include/linux/lockd/xdr4.h +4 -4
@@ -33,10 +33,10 @@ bool nlm4svc_decode_reboot(struct svc_rqst *rqstp, struct xdr_stream *xdr);bool nlm4svc_decode_shareargs (struct svc_rqst *rqstp,struct xdr_stream *xdr);bool nlm4svc_decode_notify (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); -int nlm4svc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_encode_testres (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_encode_res (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_encode_void (struct svc_rqst *rqstp,struct xdr_stream *xdr); +bool nlm4svc_encode_shareres (struct svc_rqst *rqstp,struct xdr_stream *xdr);extern const struct rpc_version nlm_version4;
include/linux/sunrpc/svc.h +1 -1
@@ -459,7 +459,7 @@ struct svc_procedure {bool (*pc_decode)(struct svc_rqst *rqstp,struct xdr_stream *xdr);/* XDR encode result: */ -int (*pc_encode)(struct svc_rqst *rqstp, +bool (*pc_encode)(struct svc_rqst *rqstp,struct xdr_stream *xdr);/* XDR free result: */ void (*pc_release)(struct svc_rqst *);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 209/690 nfsd: update create verifier comment
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: J. Bruce Fields <[email protected]>
[ Upstream commit 2336d696862186fd4a6ddd1ea0cb243b3e32847c ]
I don't know if that Solaris behavior matters any more or if it's still possible to look up that bug ID any more. The XFS behavior's definitely still relevant, though; any but the most recent XFS filesystems will lose the top bits.
--- fs/nfsd/vfs.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/nfsd/vfs.c +2 -1
@@ -1436,7 +1436,8 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,if (nfsd_create_is_exclusive (createmode)) {/* solaris7 gets confused (bugid 4218508) if these have -* the high bit set, so just clear the high bits. If this is +* the high bit set, as do xfs filesystems without the +* "bigtime" feature. So just clear the high bits. If this is * ever changed to use different attrs for storing the * verifier, then do_open_lookup() will also need to be fixed * accordingly.
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 210/690 NFSD:fix boolreturn.cocci warning
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Changcheng Deng <[email protected]>
[ Upstream commit 291cd656da04163f4bba67953c1f2f823e0d1231 ]
./fs/nfsd/nfssvc.c: 1072: 8-9: :WARNING return of 0/1 in function 'nfssvc_decode_voidarg' with return type bool
Return statements in functions returning bool should use true/false instead of 1/0.
--- fs/nfsd/nfssvc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/nfsd/nfssvc.c +1 -1
@@ -1069,7 +1069,7 @@ int nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)*/ bool nfssvc_decode_voidarg (struct svc_rqst *rqstp,struct xdr_stream *xdr) { -return 1 ; +return true; }/**
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 211/690 nfsd4: remove obselete comment
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: J. Bruce Fields <[email protected]>
[ Upstream commit 80479eb862102f9513e93fcf726c78cc0be2e3b2 ]
Mandatory locking has been removed. And the rest of this comment is redundant with the code.
--- fs/nfsd/vfs.c | 3 --- 1 file changed, 3 deletions(-)
fs/nfsd/vfs.c +0 -3
@@ -744,9 +744,6 @@ __nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, path.dentry = fhp->fh_dentry; inode =d_inode (path.dentry); -/* Disallow write access to files with the append-only bit set -* or any access when mandatory locking enabled -*/ err = nfserr_perm;if (IS_APPEND (inode) && (may_flags &NFSD_MAY_WRITE )) goto out;
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 212/690 ext4: fix error code saved on super block during file system abort
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Gabriel Krisman Bertazi <[email protected]>
[ Upstream commit 124e7c61deb27d758df5ec0521c36cf08d417f7a ]
ext4_abort will eventually call ext4_errno_to_code, which translates the errno to an EXT4_ERR specific error. This means that ext4_abort expects an errno. By using EXT4_ERR_ here, it gets misinterpreted (as an errno), and ends up saving EXT4_ERR_EBUSY on the superblock during an abort, which makes no sense.
ESHUTDOWN will get properly translated to EXT4_ERR_SHUTDOWN, so use that instead.
--- fs/ext4/super.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/ext4/super.c +1 -1
@@ -5851,7 +5851,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) }if (ext4_test_mount_flag (sb,EXT4_MF_FS_ABORTED )) -ext4_abort (sb,EXT4_ERR_ESHUTDOWN ,"Abort forced by user" ); +ext4_abort (sb,ESHUTDOWN ,"Abort forced by user" ); sb->s_flags = (sb->s_flags & ~SB_POSIXACL ) | (test_opt (sb,POSIX_ACL ) ?SB_POSIXACL :0 );
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 213/690 fsnotify: clarify object type argument
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Amir Goldstein <[email protected]>
[ Upstream commit ad69cd9972e79aba103ba5365de0acd35770c265 ]
In preparation for separating object type from iterator type, rename some 'type' arguments in functions to 'obj_type' and remove the unused interface to clear marks by object type mask.
--- fs/notify/fanotify/fanotify_user.c | 8 ++++---- fs/notify/group.c | 2 +- fs/notify/mark.c | 27 +++++++++++++++------------ include/linux/fsnotify_backend.h | 28 ++++++++++++---------------- 4 files changed, 32 insertions(+), 33 deletions(-)
fs/notify/fanotify/fanotify_user.c +4 -4
@@ -1057,7 +1057,7 @@ static __u32 fanotify_mark_add_to_mask(struct fsnotify_mark *fsn_mark,static struct fsnotify_mark *fanotify_add_new_mark (struct fsnotify_group *group,fsnotify_connp_t *connp, -unsigned int type, +unsigned int obj_type,__kernel_fsid_t *fsid) {struct ucounts *ucounts = group->fanotify_data.ucounts;
@@ -1080,7 +1080,7 @@ static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group, }fsnotify_init_mark (mark, group); - ret =fsnotify_add_mark_locked (mark, connp, type,0 , fsid); + ret =fsnotify_add_mark_locked (mark, connp, obj_type,0 , fsid);if (ret) {fsnotify_put_mark (mark); goto out_dec_ucounts;
@@ -1105,7 +1105,7 @@ static int fanotify_group_init_error_pool(struct fsnotify_group *group) }static int fanotify_add_mark (struct fsnotify_group *group, -fsnotify_connp_t *connp,unsigned int type, +fsnotify_connp_t *connp,unsigned int obj_type,__u32 mask,unsigned int flags,__kernel_fsid_t *fsid) {
@@ -1116,7 +1116,7 @@ static int fanotify_add_mark(struct fsnotify_group *group,mutex_lock (&group->mark_mutex); fsn_mark =fsnotify_find_mark (connp, group);if (!fsn_mark) { - fsn_mark =fanotify_add_new_mark (group, connp, type, fsid); + fsn_mark =fanotify_add_new_mark (group, connp, obj_type, fsid);if (IS_ERR (fsn_mark)) {mutex_unlock (&group->mark_mutex);return PTR_ERR (fsn_mark);
fs/notify/group.c +1 -1
@@ -58,7 +58,7 @@ void fsnotify_destroy_group(struct fsnotify_group *group)fsnotify_group_stop_queueing (group);/* Clear all marks for this group and queue them for destruction */ -fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_ALL_TYPES_MASK ); +fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_ANY );/* * Some marks can still be pinned when waiting for response from
fs/notify/mark.c +15 -12
@@ -496,7 +496,7 @@ int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b) }static int fsnotify_attach_connector_to_object (fsnotify_connp_t *connp, -unsigned int type, +unsigned int obj_type,__kernel_fsid_t *fsid) {struct inode *inode =NULL ;
@@ -507,7 +507,7 @@ static int fsnotify_attach_connector_to_object(fsnotify_connp_t *connp,return -ENOMEM ;spin_lock_init (&conn->lock);INIT_HLIST_HEAD (&conn->list); - conn->type = type; + conn->type = obj_type; conn->obj = connp;/* Cache fsid of filesystem containing the object */ if (fsid) {
@@ -572,7 +572,8 @@ static struct fsnotify_mark_connector *fsnotify_grab_connector(* priority, highest number first, and then by the group's location in memory. */ static int fsnotify_add_mark_list (struct fsnotify_mark *mark, -fsnotify_connp_t *connp,unsigned int type, +fsnotify_connp_t *connp, +unsigned int obj_type,int allow_dups,__kernel_fsid_t *fsid) {struct fsnotify_mark *lmark, *last =NULL ;
@@ -580,7 +581,7 @@ static int fsnotify_add_mark_list(struct fsnotify_mark *mark,int cmp;int err =0 ; -if (WARN_ON (!fsnotify_valid_obj_type (type))) +if (WARN_ON (!fsnotify_valid_obj_type (obj_type)))return -EINVAL ;/* Backend is expected to check for zero fsid (e.g. tmpfs) */
@@ -592,7 +593,8 @@ static int fsnotify_add_mark_list(struct fsnotify_mark *mark, conn =fsnotify_grab_connector (connp);if (!conn) {spin_unlock (&mark->lock); - err =fsnotify_attach_connector_to_object (connp, type, fsid); + err =fsnotify_attach_connector_to_object (connp, obj_type, + fsid);if (err)return err; goto restart;
@@ -665,7 +667,7 @@ static int fsnotify_add_mark_list(struct fsnotify_mark *mark,* event types should be delivered to which group. */ int fsnotify_add_mark_locked (struct fsnotify_mark *mark, -fsnotify_connp_t *connp,unsigned int type, +fsnotify_connp_t *connp,unsigned int obj_type,int allow_dups,__kernel_fsid_t *fsid) {struct fsnotify_group *group = mark->group;
@@ -686,7 +688,7 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,fsnotify_get_mark (mark);/* for g_list */ spin_unlock (&mark->lock); - ret =fsnotify_add_mark_list (mark, connp, type, allow_dups, fsid); + ret =fsnotify_add_mark_list (mark, connp, obj_type, allow_dups, fsid);if (ret) goto err;
@@ -706,13 +708,14 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark, }int fsnotify_add_mark (struct fsnotify_mark *mark,fsnotify_connp_t *connp, -unsigned int type,int allow_dups,__kernel_fsid_t *fsid) +unsigned int obj_type,int allow_dups, +__kernel_fsid_t *fsid) {int ret;struct fsnotify_group *group = mark->group;mutex_lock (&group->mark_mutex); - ret =fsnotify_add_mark_locked (mark, connp, type, allow_dups, fsid); + ret =fsnotify_add_mark_locked (mark, connp, obj_type, allow_dups, fsid);mutex_unlock (&group->mark_mutex);return ret; }
@@ -747,14 +750,14 @@ EXPORT_SYMBOL_GPL(fsnotify_find_mark);/* Clear any marks in a group with given type mask */ void fsnotify_clear_marks_by_group (struct fsnotify_group *group, -unsigned int type_mask) +unsigned int obj_type) {struct fsnotify_mark *lmark, *mark;LIST_HEAD (to_free);struct list_head *head = &to_free;/* Skip selection step if we want to clear all marks. */ -if (type_mask ==FSNOTIFY_OBJ_ALL_TYPES_MASK ) { +if (obj_type ==FSNOTIFY_OBJ_TYPE_ANY ) { head = &group->marks_list; goto clear; }
@@ -769,7 +772,7 @@ void fsnotify_clear_marks_by_group(struct fsnotify_group *group,*/ mutex_lock (&group->mark_mutex);list_for_each_entry_safe (mark, lmark, &group->marks_list, g_list) { -if ((1U << mark->connector->type) & type_mask) +if (mark->connector->type == obj_type)list_move (&mark->g_list, &to_free); }mutex_unlock (&group->mark_mutex);
include/linux/fsnotify_backend.h +12 -16
@@ -338,6 +338,7 @@ static inline struct fs_error_report *fsnotify_data_error_report( }enum fsnotify_obj_type { +FSNOTIFY_OBJ_TYPE_ANY =-1 ,FSNOTIFY_OBJ_TYPE_INODE ,FSNOTIFY_OBJ_TYPE_PARENT ,FSNOTIFY_OBJ_TYPE_VFSMOUNT ,
@@ -346,15 +347,9 @@ enum fsnotify_obj_type {FSNOTIFY_OBJ_TYPE_DETACHED =FSNOTIFY_OBJ_TYPE_COUNT }; -#define FSNOTIFY_OBJ_TYPE_INODE_FL (1U << FSNOTIFY_OBJ_TYPE_INODE) -#define FSNOTIFY_OBJ_TYPE_PARENT_FL (1U << FSNOTIFY_OBJ_TYPE_PARENT) -#define FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL (1U << FSNOTIFY_OBJ_TYPE_VFSMOUNT) -#define FSNOTIFY_OBJ_TYPE_SB_FL (1U << FSNOTIFY_OBJ_TYPE_SB) -#define FSNOTIFY_OBJ_ALL_TYPES_MASK ((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1) - -static inline bool fsnotify_valid_obj_type (unsigned int type) +static inline bool fsnotify_valid_obj_type (unsigned int obj_type) { -return (type <FSNOTIFY_OBJ_TYPE_COUNT ); +return (obj_type <FSNOTIFY_OBJ_TYPE_COUNT ); }struct fsnotify_iter_info {
@@ -387,7 +382,7 @@ static inline void fsnotify_iter_set_report_type_mark( static inline struct fsnotify_mark *fsnotify_iter_##name##_mark( \ struct fsnotify_iter_info *iter_info) \ { \ - return (iter_info->report_mask & FSNOTIFY_OBJ_TYPE_##NAME##_FL) ? \ + return (iter_info->report_mask & (1U << FSNOTIFY_OBJ_TYPE_##NAME)) ? \ iter_info->marks[FSNOTIFY_OBJ_TYPE_##NAME] : NULL; \ }
@@ -604,11 +599,11 @@ extern int fsnotify_get_conn_fsid(const struct fsnotify_mark_connector *conn, __kernel_fsid_t *fsid);/* attach the mark to the object */ extern int fsnotify_add_mark (struct fsnotify_mark *mark, -fsnotify_connp_t *connp,unsigned int type, +fsnotify_connp_t *connp,unsigned int obj_type,int allow_dups,__kernel_fsid_t *fsid);extern int fsnotify_add_mark_locked (struct fsnotify_mark *mark,fsnotify_connp_t *connp, -unsigned int type,int allow_dups, +unsigned int obj_type,int allow_dups,__kernel_fsid_t *fsid);/* attach the mark to the inode */
@@ -637,22 +632,23 @@ extern void fsnotify_detach_mark(struct fsnotify_mark *mark);extern void fsnotify_free_mark (struct fsnotify_mark *mark);/* Wait until all marks queued for destruction are destroyed */ extern void fsnotify_wait_marks_destroyed (void ); -/* run all the marks in a group, and clear all of the marks attached to given object type */ -extern void fsnotify_clear_marks_by_group (struct fsnotify_group *group,unsigned int type); +/* Clear all of the marks of a group attached to a given object type */ +extern void fsnotify_clear_marks_by_group (struct fsnotify_group *group, +unsigned int obj_type);/* run all the marks in a group, and clear all of the vfsmount marks */ static inline void fsnotify_clear_vfsmount_marks_by_group (struct fsnotify_group *group) { -fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL ); +fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_VFSMOUNT ); }/* run all the marks in a group, and clear all of the inode marks */ static inline void fsnotify_clear_inode_marks_by_group (struct fsnotify_group *group) { -fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_INODE_FL ); +fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_INODE ); }/* run all the marks in a group, and clear all of the sn marks */ static inline void fsnotify_clear_sb_marks_by_group (struct fsnotify_group *group) { -fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_SB_FL ); +fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_SB ); }extern void fsnotify_get_mark (struct fsnotify_mark *mark);extern void fsnotify_put_mark (struct fsnotify_mark *mark);
Signature · 1 line
2.43.0
Greg Kroah-Hartman
maintainerPATCH 214/690 fsnotify: separate mark iterator type from object type enum
In reply to Greg Kroah-Hartman5.15-stable review patch. If anyone has any objections, please let me know.
------------------
From: Amir Goldstein <[email protected]>
[ Upstream commit 1c9007d62bea6fd164285314f7553f73e5308863 ]
They are two different types that use the same enum, so this confusing.
Use the object type to indicate the type of object mark is attached to and the iter type to indicate the type of watch.
A group can have two different watches of the same object type (parent and child watches) that match the same event.
--- fs/notify/fanotify/fanotify.c | 6 ++--- fs/notify/fsnotify.c | 18 +++++++------- fs/notify/mark.c | 4 ++-- include/linux/fsnotify_backend.h | 41 ++++++++++++++++++++++---------- 4 files changed, 42 insertions(+), 27 deletions(-)
fs/notify/fanotify/fanotify.c +3 -3
@@ -299,7 +299,7 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,return 0 ; } -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) {if (!fsnotify_iter_should_report_type (iter_info, type))continue ; mark = iter_info->marks[type];
@@ -318,7 +318,7 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,* If the event is on a child and this mark is on a parent not * watching children, don't send it! */ -if (type ==FSNOTIFY_OBJ_TYPE_PARENT && +if (type ==FSNOTIFY_ITER_TYPE_PARENT && !(mark->mask &FS_EVENT_ON_CHILD ))continue ;
@@ -746,7 +746,7 @@ static __kernel_fsid_t fanotify_get_fsid(struct fsnotify_iter_info *iter_info)int type;__kernel_fsid_t fsid = {}; -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) {struct fsnotify_mark_connector *conn;if (!fsnotify_iter_should_report_type (iter_info, type))
fs/notify/fsnotify.c +9 -9
@@ -330,7 +330,7 @@ static int send_to_group(__u32 mask, const void *data, int data_type,/* clear ignored on inode modification */ if (mask &FS_MODIFY ) { -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) {if (!fsnotify_iter_should_report_type (iter_info, type))continue ; mark = iter_info->marks[type];
@@ -340,7 +340,7 @@ static int send_to_group(__u32 mask, const void *data, int data_type, } } -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) {if (!fsnotify_iter_should_report_type (iter_info, type))continue ; mark = iter_info->marks[type];
@@ -405,7 +405,7 @@ static unsigned int fsnotify_iter_select_report_types(int type;/* Choose max prio group among groups of all queue heads */ -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) { mark = iter_info->marks[type];if (mark &&fsnotify_compare_groups (max_prio_group, mark->group) >0 )
@@ -417,7 +417,7 @@ static unsigned int fsnotify_iter_select_report_types(/* Set the report mask for marks from same group as max prio group */ iter_info->report_mask =0 ; -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) { mark = iter_info->marks[type];if (mark &&fsnotify_compare_groups (max_prio_group, mark->group) ==0 )
@@ -435,7 +435,7 @@ static void fsnotify_iter_next(struct fsnotify_iter_info *iter_info) {int type; -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) {if (fsnotify_iter_should_report_type (iter_info, type)) iter_info->marks[type] =fsnotify_next_mark (iter_info->marks[type]);
@@ -519,18 +519,18 @@ int fsnotify(__u32 mask, const void *data, int data_type, struct inode *dir, iter_info.srcu_idx =srcu_read_lock (&fsnotify_mark_srcu); - iter_info.marks[FSNOTIFY_OBJ_TYPE_SB ] = + iter_info.marks[FSNOTIFY_ITER_TYPE_SB ] =fsnotify_first_mark (&sb->s_fsnotify_marks);if (mnt) { - iter_info.marks[FSNOTIFY_OBJ_TYPE_VFSMOUNT ] = + iter_info.marks[FSNOTIFY_ITER_TYPE_VFSMOUNT ] =fsnotify_first_mark (&mnt->mnt_fsnotify_marks); }if (inode) { - iter_info.marks[FSNOTIFY_OBJ_TYPE_INODE ] = + iter_info.marks[FSNOTIFY_ITER_TYPE_INODE ] =fsnotify_first_mark (&inode->i_fsnotify_marks); }if (parent) { - iter_info.marks[FSNOTIFY_OBJ_TYPE_PARENT ] = + iter_info.marks[FSNOTIFY_ITER_TYPE_PARENT ] =fsnotify_first_mark (&parent->i_fsnotify_marks); }
fs/notify/mark.c +2 -2
@@ -353,7 +353,7 @@ bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info) {int type; -fsnotify_foreach_obj_type (type) { +fsnotify_foreach_iter_type (type) {/* This can fail if mark is being removed */ if (!fsnotify_get_mark_safe (iter_info->marks[type])) {__release (&fsnotify_mark_srcu);
@@ -382,7 +382,7 @@ void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info)int type; iter_info->srcu_idx =srcu_read_lock (&fsnotify_mark_srcu); -fsnotify_foreach_obj_type (type) +fsnotify_foreach_iter_type (type) fsnotify_put_mark_wake(iter_info->marks[type]); }
include/linux/fsnotify_backend.h +28 -13
83 lines not on this page · raw message
Signature · 1 line
2.43.0