1 |
commit: 3edfc78903fedcfaadc1793c5ad499b61ac126c2 |
2 |
Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> |
3 |
AuthorDate: Sat Jun 25 19:44:07 2022 +0000 |
4 |
Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> |
5 |
CommitDate: Sat Jun 25 19:44:07 2022 +0000 |
6 |
URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=3edfc789 |
7 |
|
8 |
Linux patch 5.15.50 |
9 |
|
10 |
Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> |
11 |
|
12 |
0000_README | 4 + |
13 |
1049_linux-5.15.50.patch | 527 +++++++++++++++++++++++++++++++++++++++++++++++ |
14 |
2 files changed, 531 insertions(+) |
15 |
|
16 |
diff --git a/0000_README b/0000_README |
17 |
index 35920ee0..b568efe1 100644 |
18 |
--- a/0000_README |
19 |
+++ b/0000_README |
20 |
@@ -239,6 +239,10 @@ Patch: 1048_linux-5.15.49.patch |
21 |
From: http://www.kernel.org |
22 |
Desc: Linux 5.15.49 |
23 |
|
24 |
+Patch: 1049_linux-5.15.50.patch |
25 |
+From: http://www.kernel.org |
26 |
+Desc: Linux 5.15.50 |
27 |
+ |
28 |
Patch: 1500_XATTR_USER_PREFIX.patch |
29 |
From: https://bugs.gentoo.org/show_bug.cgi?id=470644 |
30 |
Desc: Support for namespace user.pax.* on tmpfs. |
31 |
|
32 |
diff --git a/1049_linux-5.15.50.patch b/1049_linux-5.15.50.patch |
33 |
new file mode 100644 |
34 |
index 00000000..ad053d8b |
35 |
--- /dev/null |
36 |
+++ b/1049_linux-5.15.50.patch |
37 |
@@ -0,0 +1,527 @@ |
38 |
+diff --git a/Makefile b/Makefile |
39 |
+index 3e9782979b7c8..03b3a493fcca1 100644 |
40 |
+--- a/Makefile |
41 |
++++ b/Makefile |
42 |
+@@ -1,7 +1,7 @@ |
43 |
+ # SPDX-License-Identifier: GPL-2.0 |
44 |
+ VERSION = 5 |
45 |
+ PATCHLEVEL = 15 |
46 |
+-SUBLEVEL = 49 |
47 |
++SUBLEVEL = 50 |
48 |
+ EXTRAVERSION = |
49 |
+ NAME = Trick or Treat |
50 |
+ |
51 |
+diff --git a/arch/arm64/mm/cache.S b/arch/arm64/mm/cache.S |
52 |
+index 5051b3c1a4f12..79164e4390369 100644 |
53 |
+--- a/arch/arm64/mm/cache.S |
54 |
++++ b/arch/arm64/mm/cache.S |
55 |
+@@ -231,8 +231,6 @@ SYM_FUNC_END_PI(__dma_flush_area) |
56 |
+ */ |
57 |
+ SYM_FUNC_START_PI(__dma_map_area) |
58 |
+ add x1, x0, x1 |
59 |
+- cmp w2, #DMA_FROM_DEVICE |
60 |
+- b.eq __dma_inv_area |
61 |
+ b __dma_clean_area |
62 |
+ SYM_FUNC_END_PI(__dma_map_area) |
63 |
+ |
64 |
+diff --git a/arch/s390/mm/pgtable.c b/arch/s390/mm/pgtable.c |
65 |
+index 6ad634a27d5b9..df0adb7e2fe8e 100644 |
66 |
+--- a/arch/s390/mm/pgtable.c |
67 |
++++ b/arch/s390/mm/pgtable.c |
68 |
+@@ -748,7 +748,7 @@ void ptep_zap_key(struct mm_struct *mm, unsigned long addr, pte_t *ptep) |
69 |
+ pgste_val(pgste) |= PGSTE_GR_BIT | PGSTE_GC_BIT; |
70 |
+ ptev = pte_val(*ptep); |
71 |
+ if (!(ptev & _PAGE_INVALID) && (ptev & _PAGE_WRITE)) |
72 |
+- page_set_storage_key(ptev & PAGE_MASK, PAGE_DEFAULT_KEY, 1); |
73 |
++ page_set_storage_key(ptev & PAGE_MASK, PAGE_DEFAULT_KEY, 0); |
74 |
+ pgste_set_unlock(ptep, pgste); |
75 |
+ preempt_enable(); |
76 |
+ } |
77 |
+diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c |
78 |
+index dff6238ca9adb..d2aecf7bf66b4 100644 |
79 |
+--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c |
80 |
++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c |
81 |
+@@ -989,6 +989,32 @@ static int dm_dmub_hw_init(struct amdgpu_device *adev) |
82 |
+ return 0; |
83 |
+ } |
84 |
+ |
85 |
++static void dm_dmub_hw_resume(struct amdgpu_device *adev) |
86 |
++{ |
87 |
++ struct dmub_srv *dmub_srv = adev->dm.dmub_srv; |
88 |
++ enum dmub_status status; |
89 |
++ bool init; |
90 |
++ |
91 |
++ if (!dmub_srv) { |
92 |
++ /* DMUB isn't supported on the ASIC. */ |
93 |
++ return; |
94 |
++ } |
95 |
++ |
96 |
++ status = dmub_srv_is_hw_init(dmub_srv, &init); |
97 |
++ if (status != DMUB_STATUS_OK) |
98 |
++ DRM_WARN("DMUB hardware init check failed: %d\n", status); |
99 |
++ |
100 |
++ if (status == DMUB_STATUS_OK && init) { |
101 |
++ /* Wait for firmware load to finish. */ |
102 |
++ status = dmub_srv_wait_for_auto_load(dmub_srv, 100000); |
103 |
++ if (status != DMUB_STATUS_OK) |
104 |
++ DRM_WARN("Wait for DMUB auto-load failed: %d\n", status); |
105 |
++ } else { |
106 |
++ /* Perform the full hardware initialization. */ |
107 |
++ dm_dmub_hw_init(adev); |
108 |
++ } |
109 |
++} |
110 |
++ |
111 |
+ #if defined(CONFIG_DRM_AMD_DC_DCN) |
112 |
+ static void mmhub_read_system_context(struct amdgpu_device *adev, struct dc_phy_addr_space_config *pa_config) |
113 |
+ { |
114 |
+@@ -2268,9 +2294,7 @@ static int dm_resume(void *handle) |
115 |
+ amdgpu_dm_outbox_init(adev); |
116 |
+ |
117 |
+ /* Before powering on DC we need to re-initialize DMUB. */ |
118 |
+- r = dm_dmub_hw_init(adev); |
119 |
+- if (r) |
120 |
+- DRM_ERROR("DMUB interface failed to initialize: status=%d\n", r); |
121 |
++ dm_dmub_hw_resume(adev); |
122 |
+ |
123 |
+ /* power on hardware */ |
124 |
+ dc_set_power_state(dm->dc, DC_ACPI_CM_POWER_STATE_D0); |
125 |
+diff --git a/drivers/net/ethernet/microsoft/mana/mana_en.c b/drivers/net/ethernet/microsoft/mana/mana_en.c |
126 |
+index 030ae89f3a337..18dc64d7f412f 100644 |
127 |
+--- a/drivers/net/ethernet/microsoft/mana/mana_en.c |
128 |
++++ b/drivers/net/ethernet/microsoft/mana/mana_en.c |
129 |
+@@ -980,8 +980,10 @@ static void mana_process_rx_cqe(struct mana_rxq *rxq, struct mana_cq *cq, |
130 |
+ break; |
131 |
+ |
132 |
+ case CQE_RX_TRUNCATED: |
133 |
+- netdev_err(ndev, "Dropped a truncated packet\n"); |
134 |
+- return; |
135 |
++ ++ndev->stats.rx_dropped; |
136 |
++ rxbuf_oob = &rxq->rx_oobs[rxq->buf_index]; |
137 |
++ netdev_warn_once(ndev, "Dropped a truncated packet\n"); |
138 |
++ goto drop; |
139 |
+ |
140 |
+ case CQE_RX_COALESCED_4: |
141 |
+ netdev_err(ndev, "RX coalescing is unsupported\n"); |
142 |
+@@ -1043,6 +1045,7 @@ static void mana_process_rx_cqe(struct mana_rxq *rxq, struct mana_cq *cq, |
143 |
+ |
144 |
+ mana_rx_skb(old_buf, oob, rxq); |
145 |
+ |
146 |
++drop: |
147 |
+ mana_move_wq_tail(rxq->gdma_rq, rxbuf_oob->wqe_inf.wqe_size_in_bu); |
148 |
+ |
149 |
+ mana_post_pkt_rxq(rxq); |
150 |
+diff --git a/drivers/tty/serial/amba-pl011.c b/drivers/tty/serial/amba-pl011.c |
151 |
+index 3d40306971b81..0e908061b5d7d 100644 |
152 |
+--- a/drivers/tty/serial/amba-pl011.c |
153 |
++++ b/drivers/tty/serial/amba-pl011.c |
154 |
+@@ -1620,13 +1620,6 @@ static void pl011_set_mctrl(struct uart_port *port, unsigned int mctrl) |
155 |
+ container_of(port, struct uart_amba_port, port); |
156 |
+ unsigned int cr; |
157 |
+ |
158 |
+- if (port->rs485.flags & SER_RS485_ENABLED) { |
159 |
+- if (port->rs485.flags & SER_RS485_RTS_AFTER_SEND) |
160 |
+- mctrl &= ~TIOCM_RTS; |
161 |
+- else |
162 |
+- mctrl |= TIOCM_RTS; |
163 |
+- } |
164 |
+- |
165 |
+ cr = pl011_read(uap, REG_CR); |
166 |
+ |
167 |
+ #define TIOCMBIT(tiocmbit, uartbit) \ |
168 |
+@@ -1850,14 +1843,8 @@ static int pl011_startup(struct uart_port *port) |
169 |
+ cr = uap->old_cr & (UART011_CR_RTS | UART011_CR_DTR); |
170 |
+ cr |= UART01x_CR_UARTEN | UART011_CR_RXE; |
171 |
+ |
172 |
+- if (port->rs485.flags & SER_RS485_ENABLED) { |
173 |
+- if (port->rs485.flags & SER_RS485_RTS_AFTER_SEND) |
174 |
+- cr &= ~UART011_CR_RTS; |
175 |
+- else |
176 |
+- cr |= UART011_CR_RTS; |
177 |
+- } else { |
178 |
++ if (!(port->rs485.flags & SER_RS485_ENABLED)) |
179 |
+ cr |= UART011_CR_TXE; |
180 |
+- } |
181 |
+ |
182 |
+ pl011_write(cr, uap, REG_CR); |
183 |
+ |
184 |
+diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c |
185 |
+index eb15423f935a3..4d3ad4c6c60f0 100644 |
186 |
+--- a/drivers/tty/serial/serial_core.c |
187 |
++++ b/drivers/tty/serial/serial_core.c |
188 |
+@@ -144,6 +144,11 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear) |
189 |
+ unsigned long flags; |
190 |
+ unsigned int old; |
191 |
+ |
192 |
++ if (port->rs485.flags & SER_RS485_ENABLED) { |
193 |
++ set &= ~TIOCM_RTS; |
194 |
++ clear &= ~TIOCM_RTS; |
195 |
++ } |
196 |
++ |
197 |
+ spin_lock_irqsave(&port->lock, flags); |
198 |
+ old = port->mctrl; |
199 |
+ port->mctrl = (old & ~clear) | set; |
200 |
+@@ -157,23 +162,10 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear) |
201 |
+ |
202 |
+ static void uart_port_dtr_rts(struct uart_port *uport, int raise) |
203 |
+ { |
204 |
+- int rs485_on = uport->rs485_config && |
205 |
+- (uport->rs485.flags & SER_RS485_ENABLED); |
206 |
+- int RTS_after_send = !!(uport->rs485.flags & SER_RS485_RTS_AFTER_SEND); |
207 |
+- |
208 |
+- if (raise) { |
209 |
+- if (rs485_on && RTS_after_send) { |
210 |
+- uart_set_mctrl(uport, TIOCM_DTR); |
211 |
+- uart_clear_mctrl(uport, TIOCM_RTS); |
212 |
+- } else { |
213 |
+- uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS); |
214 |
+- } |
215 |
+- } else { |
216 |
+- unsigned int clear = TIOCM_DTR; |
217 |
+- |
218 |
+- clear |= (!rs485_on || RTS_after_send) ? TIOCM_RTS : 0; |
219 |
+- uart_clear_mctrl(uport, clear); |
220 |
+- } |
221 |
++ if (raise) |
222 |
++ uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS); |
223 |
++ else |
224 |
++ uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS); |
225 |
+ } |
226 |
+ |
227 |
+ /* |
228 |
+@@ -1089,11 +1081,6 @@ uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear) |
229 |
+ goto out; |
230 |
+ |
231 |
+ if (!tty_io_error(tty)) { |
232 |
+- if (uport->rs485.flags & SER_RS485_ENABLED) { |
233 |
+- set &= ~TIOCM_RTS; |
234 |
+- clear &= ~TIOCM_RTS; |
235 |
+- } |
236 |
+- |
237 |
+ uart_update_mctrl(uport, set, clear); |
238 |
+ ret = 0; |
239 |
+ } |
240 |
+@@ -2408,6 +2395,9 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, |
241 |
+ */ |
242 |
+ spin_lock_irqsave(&port->lock, flags); |
243 |
+ port->mctrl &= TIOCM_DTR; |
244 |
++ if (port->rs485.flags & SER_RS485_ENABLED && |
245 |
++ !(port->rs485.flags & SER_RS485_RTS_AFTER_SEND)) |
246 |
++ port->mctrl |= TIOCM_RTS; |
247 |
+ port->ops->set_mctrl(port, port->mctrl); |
248 |
+ spin_unlock_irqrestore(&port->lock, flags); |
249 |
+ |
250 |
+diff --git a/drivers/usb/gadget/function/u_ether.c b/drivers/usb/gadget/function/u_ether.c |
251 |
+index d15a54f6c24b9..ef253599dcf96 100644 |
252 |
+--- a/drivers/usb/gadget/function/u_ether.c |
253 |
++++ b/drivers/usb/gadget/function/u_ether.c |
254 |
+@@ -774,9 +774,13 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g, |
255 |
+ dev->qmult = qmult; |
256 |
+ snprintf(net->name, sizeof(net->name), "%s%%d", netname); |
257 |
+ |
258 |
+- if (get_ether_addr(dev_addr, net->dev_addr)) |
259 |
++ if (get_ether_addr(dev_addr, net->dev_addr)) { |
260 |
++ net->addr_assign_type = NET_ADDR_RANDOM; |
261 |
+ dev_warn(&g->dev, |
262 |
+ "using random %s ethernet address\n", "self"); |
263 |
++ } else { |
264 |
++ net->addr_assign_type = NET_ADDR_SET; |
265 |
++ } |
266 |
+ if (get_ether_addr(host_addr, dev->host_mac)) |
267 |
+ dev_warn(&g->dev, |
268 |
+ "using random %s ethernet address\n", "host"); |
269 |
+@@ -833,6 +837,9 @@ struct net_device *gether_setup_name_default(const char *netname) |
270 |
+ INIT_LIST_HEAD(&dev->tx_reqs); |
271 |
+ INIT_LIST_HEAD(&dev->rx_reqs); |
272 |
+ |
273 |
++ /* by default we always have a random MAC address */ |
274 |
++ net->addr_assign_type = NET_ADDR_RANDOM; |
275 |
++ |
276 |
+ skb_queue_head_init(&dev->rx_frames); |
277 |
+ |
278 |
+ /* network device setup */ |
279 |
+@@ -869,7 +876,6 @@ int gether_register_netdev(struct net_device *net) |
280 |
+ dev = netdev_priv(net); |
281 |
+ g = dev->gadget; |
282 |
+ |
283 |
+- net->addr_assign_type = NET_ADDR_RANDOM; |
284 |
+ eth_hw_addr_set(net, dev->dev_mac); |
285 |
+ |
286 |
+ status = register_netdev(net); |
287 |
+@@ -910,6 +916,7 @@ int gether_set_dev_addr(struct net_device *net, const char *dev_addr) |
288 |
+ if (get_ether_addr(dev_addr, new_addr)) |
289 |
+ return -EINVAL; |
290 |
+ memcpy(dev->dev_mac, new_addr, ETH_ALEN); |
291 |
++ net->addr_assign_type = NET_ADDR_SET; |
292 |
+ return 0; |
293 |
+ } |
294 |
+ EXPORT_SYMBOL_GPL(gether_set_dev_addr); |
295 |
+diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c |
296 |
+index efea20a4b0e95..ecf564d150b3c 100644 |
297 |
+--- a/fs/zonefs/super.c |
298 |
++++ b/fs/zonefs/super.c |
299 |
+@@ -72,15 +72,51 @@ static inline void zonefs_i_size_write(struct inode *inode, loff_t isize) |
300 |
+ zi->i_flags &= ~ZONEFS_ZONE_OPEN; |
301 |
+ } |
302 |
+ |
303 |
+-static int zonefs_iomap_begin(struct inode *inode, loff_t offset, loff_t length, |
304 |
+- unsigned int flags, struct iomap *iomap, |
305 |
+- struct iomap *srcmap) |
306 |
++static int zonefs_read_iomap_begin(struct inode *inode, loff_t offset, |
307 |
++ loff_t length, unsigned int flags, |
308 |
++ struct iomap *iomap, struct iomap *srcmap) |
309 |
+ { |
310 |
+ struct zonefs_inode_info *zi = ZONEFS_I(inode); |
311 |
+ struct super_block *sb = inode->i_sb; |
312 |
+ loff_t isize; |
313 |
+ |
314 |
+- /* All I/Os should always be within the file maximum size */ |
315 |
++ /* |
316 |
++ * All blocks are always mapped below EOF. If reading past EOF, |
317 |
++ * act as if there is a hole up to the file maximum size. |
318 |
++ */ |
319 |
++ mutex_lock(&zi->i_truncate_mutex); |
320 |
++ iomap->bdev = inode->i_sb->s_bdev; |
321 |
++ iomap->offset = ALIGN_DOWN(offset, sb->s_blocksize); |
322 |
++ isize = i_size_read(inode); |
323 |
++ if (iomap->offset >= isize) { |
324 |
++ iomap->type = IOMAP_HOLE; |
325 |
++ iomap->addr = IOMAP_NULL_ADDR; |
326 |
++ iomap->length = length; |
327 |
++ } else { |
328 |
++ iomap->type = IOMAP_MAPPED; |
329 |
++ iomap->addr = (zi->i_zsector << SECTOR_SHIFT) + iomap->offset; |
330 |
++ iomap->length = isize - iomap->offset; |
331 |
++ } |
332 |
++ mutex_unlock(&zi->i_truncate_mutex); |
333 |
++ |
334 |
++ trace_zonefs_iomap_begin(inode, iomap); |
335 |
++ |
336 |
++ return 0; |
337 |
++} |
338 |
++ |
339 |
++static const struct iomap_ops zonefs_read_iomap_ops = { |
340 |
++ .iomap_begin = zonefs_read_iomap_begin, |
341 |
++}; |
342 |
++ |
343 |
++static int zonefs_write_iomap_begin(struct inode *inode, loff_t offset, |
344 |
++ loff_t length, unsigned int flags, |
345 |
++ struct iomap *iomap, struct iomap *srcmap) |
346 |
++{ |
347 |
++ struct zonefs_inode_info *zi = ZONEFS_I(inode); |
348 |
++ struct super_block *sb = inode->i_sb; |
349 |
++ loff_t isize; |
350 |
++ |
351 |
++ /* All write I/Os should always be within the file maximum size */ |
352 |
+ if (WARN_ON_ONCE(offset + length > zi->i_max_size)) |
353 |
+ return -EIO; |
354 |
+ |
355 |
+@@ -90,7 +126,7 @@ static int zonefs_iomap_begin(struct inode *inode, loff_t offset, loff_t length, |
356 |
+ * operation. |
357 |
+ */ |
358 |
+ if (WARN_ON_ONCE(zi->i_ztype == ZONEFS_ZTYPE_SEQ && |
359 |
+- (flags & IOMAP_WRITE) && !(flags & IOMAP_DIRECT))) |
360 |
++ !(flags & IOMAP_DIRECT))) |
361 |
+ return -EIO; |
362 |
+ |
363 |
+ /* |
364 |
+@@ -99,47 +135,44 @@ static int zonefs_iomap_begin(struct inode *inode, loff_t offset, loff_t length, |
365 |
+ * write pointer) and unwriten beyond. |
366 |
+ */ |
367 |
+ mutex_lock(&zi->i_truncate_mutex); |
368 |
++ iomap->bdev = inode->i_sb->s_bdev; |
369 |
++ iomap->offset = ALIGN_DOWN(offset, sb->s_blocksize); |
370 |
++ iomap->addr = (zi->i_zsector << SECTOR_SHIFT) + iomap->offset; |
371 |
+ isize = i_size_read(inode); |
372 |
+- if (offset >= isize) |
373 |
++ if (iomap->offset >= isize) { |
374 |
+ iomap->type = IOMAP_UNWRITTEN; |
375 |
+- else |
376 |
++ iomap->length = zi->i_max_size - iomap->offset; |
377 |
++ } else { |
378 |
+ iomap->type = IOMAP_MAPPED; |
379 |
+- if (flags & IOMAP_WRITE) |
380 |
+- length = zi->i_max_size - offset; |
381 |
+- else |
382 |
+- length = min(length, isize - offset); |
383 |
++ iomap->length = isize - iomap->offset; |
384 |
++ } |
385 |
+ mutex_unlock(&zi->i_truncate_mutex); |
386 |
+ |
387 |
+- iomap->offset = ALIGN_DOWN(offset, sb->s_blocksize); |
388 |
+- iomap->length = ALIGN(offset + length, sb->s_blocksize) - iomap->offset; |
389 |
+- iomap->bdev = inode->i_sb->s_bdev; |
390 |
+- iomap->addr = (zi->i_zsector << SECTOR_SHIFT) + iomap->offset; |
391 |
+- |
392 |
+ trace_zonefs_iomap_begin(inode, iomap); |
393 |
+ |
394 |
+ return 0; |
395 |
+ } |
396 |
+ |
397 |
+-static const struct iomap_ops zonefs_iomap_ops = { |
398 |
+- .iomap_begin = zonefs_iomap_begin, |
399 |
++static const struct iomap_ops zonefs_write_iomap_ops = { |
400 |
++ .iomap_begin = zonefs_write_iomap_begin, |
401 |
+ }; |
402 |
+ |
403 |
+ static int zonefs_readpage(struct file *unused, struct page *page) |
404 |
+ { |
405 |
+- return iomap_readpage(page, &zonefs_iomap_ops); |
406 |
++ return iomap_readpage(page, &zonefs_read_iomap_ops); |
407 |
+ } |
408 |
+ |
409 |
+ static void zonefs_readahead(struct readahead_control *rac) |
410 |
+ { |
411 |
+- iomap_readahead(rac, &zonefs_iomap_ops); |
412 |
++ iomap_readahead(rac, &zonefs_read_iomap_ops); |
413 |
+ } |
414 |
+ |
415 |
+ /* |
416 |
+ * Map blocks for page writeback. This is used only on conventional zone files, |
417 |
+ * which implies that the page range can only be within the fixed inode size. |
418 |
+ */ |
419 |
+-static int zonefs_map_blocks(struct iomap_writepage_ctx *wpc, |
420 |
+- struct inode *inode, loff_t offset) |
421 |
++static int zonefs_write_map_blocks(struct iomap_writepage_ctx *wpc, |
422 |
++ struct inode *inode, loff_t offset) |
423 |
+ { |
424 |
+ struct zonefs_inode_info *zi = ZONEFS_I(inode); |
425 |
+ |
426 |
+@@ -153,12 +186,12 @@ static int zonefs_map_blocks(struct iomap_writepage_ctx *wpc, |
427 |
+ offset < wpc->iomap.offset + wpc->iomap.length) |
428 |
+ return 0; |
429 |
+ |
430 |
+- return zonefs_iomap_begin(inode, offset, zi->i_max_size - offset, |
431 |
+- IOMAP_WRITE, &wpc->iomap, NULL); |
432 |
++ return zonefs_write_iomap_begin(inode, offset, zi->i_max_size - offset, |
433 |
++ IOMAP_WRITE, &wpc->iomap, NULL); |
434 |
+ } |
435 |
+ |
436 |
+ static const struct iomap_writeback_ops zonefs_writeback_ops = { |
437 |
+- .map_blocks = zonefs_map_blocks, |
438 |
++ .map_blocks = zonefs_write_map_blocks, |
439 |
+ }; |
440 |
+ |
441 |
+ static int zonefs_writepage(struct page *page, struct writeback_control *wbc) |
442 |
+@@ -188,7 +221,8 @@ static int zonefs_swap_activate(struct swap_info_struct *sis, |
443 |
+ return -EINVAL; |
444 |
+ } |
445 |
+ |
446 |
+- return iomap_swapfile_activate(sis, swap_file, span, &zonefs_iomap_ops); |
447 |
++ return iomap_swapfile_activate(sis, swap_file, span, |
448 |
++ &zonefs_read_iomap_ops); |
449 |
+ } |
450 |
+ |
451 |
+ static const struct address_space_operations zonefs_file_aops = { |
452 |
+@@ -607,7 +641,7 @@ static vm_fault_t zonefs_filemap_page_mkwrite(struct vm_fault *vmf) |
453 |
+ |
454 |
+ /* Serialize against truncates */ |
455 |
+ filemap_invalidate_lock_shared(inode->i_mapping); |
456 |
+- ret = iomap_page_mkwrite(vmf, &zonefs_iomap_ops); |
457 |
++ ret = iomap_page_mkwrite(vmf, &zonefs_write_iomap_ops); |
458 |
+ filemap_invalidate_unlock_shared(inode->i_mapping); |
459 |
+ |
460 |
+ sb_end_pagefault(inode->i_sb); |
461 |
+@@ -862,7 +896,7 @@ static ssize_t zonefs_file_dio_write(struct kiocb *iocb, struct iov_iter *from) |
462 |
+ if (append) |
463 |
+ ret = zonefs_file_dio_append(iocb, from); |
464 |
+ else |
465 |
+- ret = iomap_dio_rw(iocb, from, &zonefs_iomap_ops, |
466 |
++ ret = iomap_dio_rw(iocb, from, &zonefs_write_iomap_ops, |
467 |
+ &zonefs_write_dio_ops, 0, 0); |
468 |
+ if (zi->i_ztype == ZONEFS_ZTYPE_SEQ && |
469 |
+ (ret > 0 || ret == -EIOCBQUEUED)) { |
470 |
+@@ -904,7 +938,7 @@ static ssize_t zonefs_file_buffered_write(struct kiocb *iocb, |
471 |
+ if (ret <= 0) |
472 |
+ goto inode_unlock; |
473 |
+ |
474 |
+- ret = iomap_file_buffered_write(iocb, from, &zonefs_iomap_ops); |
475 |
++ ret = iomap_file_buffered_write(iocb, from, &zonefs_write_iomap_ops); |
476 |
+ if (ret > 0) |
477 |
+ iocb->ki_pos += ret; |
478 |
+ else if (ret == -EIO) |
479 |
+@@ -997,7 +1031,7 @@ static ssize_t zonefs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) |
480 |
+ goto inode_unlock; |
481 |
+ } |
482 |
+ file_accessed(iocb->ki_filp); |
483 |
+- ret = iomap_dio_rw(iocb, to, &zonefs_iomap_ops, |
484 |
++ ret = iomap_dio_rw(iocb, to, &zonefs_read_iomap_ops, |
485 |
+ &zonefs_read_dio_ops, 0, 0); |
486 |
+ } else { |
487 |
+ ret = generic_file_read_iter(iocb, to); |
488 |
+diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c |
489 |
+index 40df35088cdbd..3cfba41a08298 100644 |
490 |
+--- a/kernel/bpf/btf.c |
491 |
++++ b/kernel/bpf/btf.c |
492 |
+@@ -5441,6 +5441,8 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, |
493 |
+ struct bpf_reg_state *regs, |
494 |
+ bool ptr_to_mem_ok) |
495 |
+ { |
496 |
++ enum bpf_prog_type prog_type = env->prog->type == BPF_PROG_TYPE_EXT ? |
497 |
++ env->prog->aux->dst_prog->type : env->prog->type; |
498 |
+ struct bpf_verifier_log *log = &env->log; |
499 |
+ const char *func_name, *ref_tname; |
500 |
+ const struct btf_type *t, *ref_t; |
501 |
+@@ -5533,8 +5535,7 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, |
502 |
+ reg_ref_tname); |
503 |
+ return -EINVAL; |
504 |
+ } |
505 |
+- } else if (btf_get_prog_ctx_type(log, btf, t, |
506 |
+- env->prog->type, i)) { |
507 |
++ } else if (btf_get_prog_ctx_type(log, btf, t, prog_type, i)) { |
508 |
+ /* If function expects ctx type in BTF check that caller |
509 |
+ * is passing PTR_TO_CTX. |
510 |
+ */ |
511 |
+diff --git a/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c b/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c |
512 |
+index 73b4c76e6b869..52f1426ae06e0 100644 |
513 |
+--- a/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c |
514 |
++++ b/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c |
515 |
+@@ -371,6 +371,18 @@ static void test_func_map_prog_compatibility(void) |
516 |
+ "./test_attach_probe.o"); |
517 |
+ } |
518 |
+ |
519 |
++static void test_func_replace_global_func(void) |
520 |
++{ |
521 |
++ const char *prog_name[] = { |
522 |
++ "freplace/test_pkt_access", |
523 |
++ }; |
524 |
++ |
525 |
++ test_fexit_bpf2bpf_common("./freplace_global_func.o", |
526 |
++ "./test_pkt_access.o", |
527 |
++ ARRAY_SIZE(prog_name), |
528 |
++ prog_name, false, NULL); |
529 |
++} |
530 |
++ |
531 |
+ void test_fexit_bpf2bpf(void) |
532 |
+ { |
533 |
+ if (test__start_subtest("target_no_callees")) |
534 |
+@@ -391,4 +403,6 @@ void test_fexit_bpf2bpf(void) |
535 |
+ test_func_replace_multi(); |
536 |
+ if (test__start_subtest("fmod_ret_freplace")) |
537 |
+ test_fmod_ret_freplace(); |
538 |
++ if (test__start_subtest("func_replace_global_func")) |
539 |
++ test_func_replace_global_func(); |
540 |
+ } |
541 |
+diff --git a/tools/testing/selftests/bpf/progs/freplace_global_func.c b/tools/testing/selftests/bpf/progs/freplace_global_func.c |
542 |
+new file mode 100644 |
543 |
+index 0000000000000..96cb61a6ce87a |
544 |
+--- /dev/null |
545 |
++++ b/tools/testing/selftests/bpf/progs/freplace_global_func.c |
546 |
+@@ -0,0 +1,18 @@ |
547 |
++// SPDX-License-Identifier: GPL-2.0 |
548 |
++#include <linux/bpf.h> |
549 |
++#include <bpf/bpf_helpers.h> |
550 |
++ |
551 |
++__noinline |
552 |
++int test_ctx_global_func(struct __sk_buff *skb) |
553 |
++{ |
554 |
++ volatile int retval = 1; |
555 |
++ return retval; |
556 |
++} |
557 |
++ |
558 |
++SEC("freplace/test_pkt_access") |
559 |
++int new_test_pkt_access(struct __sk_buff *skb) |
560 |
++{ |
561 |
++ return test_ctx_global_func(skb); |
562 |
++} |
563 |
++ |
564 |
++char _license[] SEC("license") = "GPL"; |