mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/fs/xfs/xfs_buf.h
..
..
@@ -18,14 +18,9 @@
18
18
 /*
19
19
  *	Base types
20
20
  */
21
+struct xfs_buf;
21
22
 
22
23
 #define XFS_BUF_DADDR_NULL	((xfs_daddr_t) (-1LL))
23
-
24
-typedef enum {
25
-	XBRW_READ = 1,			/* transfer into target memory */
26
-	XBRW_WRITE = 2,			/* transfer from target memory */
27
-	XBRW_ZERO = 3,			/* Zero target memory */
28
-} xfs_buf_rw_t;
29
24
 
30
25
 #define XBF_READ	 (1 << 0) /* buffer intended for reading from device */
31
26
 #define XBF_WRITE	 (1 << 1) /* buffer intended for writing to device */
..
..
@@ -34,22 +29,21 @@
34
29
 #define XBF_ASYNC	 (1 << 4) /* initiator will not wait for completion */
35
30
 #define XBF_DONE	 (1 << 5) /* all pages in the buffer uptodate */
36
31
 #define XBF_STALE	 (1 << 6) /* buffer has been staled, do not find it */
37
-#define XBF_WRITE_FAIL	 (1 << 24)/* async writes have failed on this buffer */
32
+#define XBF_WRITE_FAIL	 (1 << 7) /* async writes have failed on this buffer */
38
33
 
39
-/* I/O hints for the BIO layer */
40
-#define XBF_SYNCIO	 (1 << 10)/* treat this buffer as synchronous I/O */
41
-#define XBF_FUA		 (1 << 11)/* force cache write through mode */
42
-#define XBF_FLUSH	 (1 << 12)/* flush the disk cache before a write */
43
-
44
-/* flags used only as arguments to access routines */
45
-#define XBF_TRYLOCK	 (1 << 16)/* lock requested, but do not wait */
46
-#define XBF_UNMAPPED	 (1 << 17)/* do not map the buffer */
34
+/* buffer type flags for write callbacks */
35
+#define _XBF_INODES	 (1 << 16)/* inode buffer */
36
+#define _XBF_DQUOTS	 (1 << 17)/* dquot buffer */
37
+#define _XBF_LOGRECOVERY	 (1 << 18)/* log recovery buffer */
47
38
 
48
39
 /* flags used only internally */
49
40
 #define _XBF_PAGES	 (1 << 20)/* backed by refcounted pages */
50
41
 #define _XBF_KMEM	 (1 << 21)/* backed by heap memory */
51
42
 #define _XBF_DELWRI_Q	 (1 << 22)/* buffer on a delwri queue */
52
-#define _XBF_COMPOUND	 (1 << 23)/* compound buffer */
43
+
44
+/* flags used only as arguments to access routines */
45
+#define XBF_TRYLOCK	 (1 << 30)/* lock requested, but do not wait */
46
+#define XBF_UNMAPPED	 (1 << 31)/* do not map the buffer */
53
47
 
54
48
 typedef unsigned int xfs_buf_flags_t;
55
49
 
..
..
@@ -62,16 +56,15 @@
62
56
 	{ XBF_DONE,		"DONE" }, \
63
57
 	{ XBF_STALE,		"STALE" }, \
64
58
 	{ XBF_WRITE_FAIL,	"WRITE_FAIL" }, \
65
-	{ XBF_SYNCIO,		"SYNCIO" }, \
66
-	{ XBF_FUA,		"FUA" }, \
67
-	{ XBF_FLUSH,		"FLUSH" }, \
68
-	{ XBF_TRYLOCK,		"TRYLOCK" },	/* should never be set */\
69
-	{ XBF_UNMAPPED,		"UNMAPPED" },	/* ditto */\
59
+	{ _XBF_INODES,		"INODES" }, \
60
+	{ _XBF_DQUOTS,		"DQUOTS" }, \
61
+	{ _XBF_LOGRECOVERY,		"LOG_RECOVERY" }, \
70
62
 	{ _XBF_PAGES,		"PAGES" }, \
71
63
 	{ _XBF_KMEM,		"KMEM" }, \
72
64
 	{ _XBF_DELWRI_Q,	"DELWRI_Q" }, \
73
-	{ _XBF_COMPOUND,	"COMPOUND" }
74
-
65
+	/* The following interface flags should never be set */ \
66
+	{ XBF_TRYLOCK,		"TRYLOCK" }, \
67
+	{ XBF_UNMAPPED,		"UNMAPPED" }
75
68
 
76
69
 /*
77
70
  * Internal state flags.
..
..
@@ -107,11 +100,8 @@
107
100
 	struct list_lru		bt_lru;
108
101
 
109
102
 	struct percpu_counter	bt_io_count;
103
+	struct ratelimit_state	bt_ioerror_rl;
110
104
 } xfs_buftarg_t;
111
-
112
-struct xfs_buf;
113
-typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
114
-
115
105
 
116
106
 #define XB_PAGES	2
117
107
 
..
..
@@ -125,6 +115,10 @@
125
115
 
126
116
 struct xfs_buf_ops {
127
117
 	char *name;
118
+	union {
119
+		__be32 magic[2];	/* v4 and v5 on disk magic values */
120
+		__be16 magic16[2];	/* v4 and v5 on disk magic values */
121
+	};
128
122
 	void (*verify_read)(struct xfs_buf *);
129
123
 	void (*verify_write)(struct xfs_buf *);
130
124
 	xfs_failaddr_t (*verify_struct)(struct xfs_buf *bp);
..
..
@@ -157,13 +151,12 @@
157
151
 	wait_queue_head_t	b_waiters;	/* unpin waiters */
158
152
 	struct list_head	b_list;
159
153
 	struct xfs_perag	*b_pag;		/* contains rbtree root */
154
+	struct xfs_mount	*b_mount;
160
155
 	xfs_buftarg_t		*b_target;	/* buffer target (device) */
161
156
 	void			*b_addr;	/* virtual address of buffer */
162
157
 	struct work_struct	b_ioend_work;
163
-	struct workqueue_struct	*b_ioend_wq;	/* I/O completion wq */
164
-	xfs_buf_iodone_t	b_iodone;	/* I/O completion function */
165
158
 	struct completion	b_iowait;	/* queue for I/O waiters */
166
-	void			*b_log_item;
159
+	struct xfs_buf_log_item	*b_log_item;
167
160
 	struct list_head	b_li_list;	/* Log items list head */
168
161
 	struct xfs_trans	*b_transp;
169
162
 	struct page		**b_pages;	/* array of page pointers */
..
..
@@ -171,7 +164,6 @@
171
164
 	struct xfs_buf_map	*b_maps;	/* compound buffer map */
172
165
 	struct xfs_buf_map	__b_map;	/* inline compound buffer map */
173
166
 	int			b_map_count;
174
-	int			b_io_length;	/* IO size in BBs */
175
167
 	atomic_t		b_pin_count;	/* pin count */
176
168
 	atomic_t		b_io_remaining;	/* #outstanding I/O requests */
177
169
 	unsigned int		b_page_count;	/* size of page array */
..
..
@@ -205,53 +197,40 @@
205
197
 			   xfs_daddr_t blkno, size_t numblks,
206
198
 			   xfs_buf_flags_t flags);
207
199
 
208
-struct xfs_buf *_xfs_buf_alloc(struct xfs_buftarg *target,
209
-			       struct xfs_buf_map *map, int nmaps,
210
-			       xfs_buf_flags_t flags);
211
-
212
-static inline struct xfs_buf *
213
-xfs_buf_alloc(
214
-	struct xfs_buftarg	*target,
215
-	xfs_daddr_t		blkno,
216
-	size_t			numblks,
217
-	xfs_buf_flags_t		flags)
218
-{
219
-	DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
220
-	return _xfs_buf_alloc(target, &map, 1, flags);
221
-}
222
-
223
-struct xfs_buf *xfs_buf_get_map(struct xfs_buftarg *target,
224
-			       struct xfs_buf_map *map, int nmaps,
225
-			       xfs_buf_flags_t flags);
226
-struct xfs_buf *xfs_buf_read_map(struct xfs_buftarg *target,
227
-			       struct xfs_buf_map *map, int nmaps,
228
-			       xfs_buf_flags_t flags,
229
-			       const struct xfs_buf_ops *ops);
200
+int xfs_buf_get_map(struct xfs_buftarg *target, struct xfs_buf_map *map,
201
+		int nmaps, xfs_buf_flags_t flags, struct xfs_buf **bpp);
202
+int xfs_buf_read_map(struct xfs_buftarg *target, struct xfs_buf_map *map,
203
+		int nmaps, xfs_buf_flags_t flags, struct xfs_buf **bpp,
204
+		const struct xfs_buf_ops *ops, xfs_failaddr_t fa);
230
205
 void xfs_buf_readahead_map(struct xfs_buftarg *target,
231
206
 			       struct xfs_buf_map *map, int nmaps,
232
207
 			       const struct xfs_buf_ops *ops);
233
208
 
234
-static inline struct xfs_buf *
209
+static inline int
235
210
 xfs_buf_get(
236
211
 	struct xfs_buftarg	*target,
237
212
 	xfs_daddr_t		blkno,
238
213
 	size_t			numblks,
239
-	xfs_buf_flags_t		flags)
214
+	struct xfs_buf		**bpp)
240
215
 {
241
216
 	DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
242
-	return xfs_buf_get_map(target, &map, 1, flags);
217
+
218
+	return xfs_buf_get_map(target, &map, 1, 0, bpp);
243
219
 }
244
220
 
245
-static inline struct xfs_buf *
221
+static inline int
246
222
 xfs_buf_read(
247
223
 	struct xfs_buftarg	*target,
248
224
 	xfs_daddr_t		blkno,
249
225
 	size_t			numblks,
250
226
 	xfs_buf_flags_t		flags,
227
+	struct xfs_buf		**bpp,
251
228
 	const struct xfs_buf_ops *ops)
252
229
 {
253
230
 	DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
254
-	return xfs_buf_read_map(target, &map, 1, flags, ops);
231
+
232
+	return xfs_buf_read_map(target, &map, 1, flags, bpp, ops,
233
+			__builtin_return_address(0));
255
234
 }
256
235
 
257
236
 static inline void
..
..
@@ -265,18 +244,15 @@
265
244
 	return xfs_buf_readahead_map(target, &map, 1, ops);
266
245
 }
267
246
 
268
-void xfs_buf_set_empty(struct xfs_buf *bp, size_t numblks);
269
-int xfs_buf_associate_memory(struct xfs_buf *bp, void *mem, size_t length);
270
-
271
-struct xfs_buf *xfs_buf_get_uncached(struct xfs_buftarg *target, size_t numblks,
272
-				int flags);
247
+int xfs_buf_get_uncached(struct xfs_buftarg *target, size_t numblks, int flags,
248
+		struct xfs_buf **bpp);
273
249
 int xfs_buf_read_uncached(struct xfs_buftarg *target, xfs_daddr_t daddr,
274
250
 			  size_t numblks, int flags, struct xfs_buf **bpp,
275
251
 			  const struct xfs_buf_ops *ops);
252
+int _xfs_buf_read(struct xfs_buf *bp, xfs_buf_flags_t flags);
276
253
 void xfs_buf_hold(struct xfs_buf *bp);
277
254
 
278
255
 /* Releasing Buffers */
279
-extern void xfs_buf_free(xfs_buf_t *);
280
256
 extern void xfs_buf_rele(xfs_buf_t *);
281
257
 
282
258
 /* Locking and Unlocking Buffers */
..
..
@@ -286,25 +262,23 @@
286
262
 #define xfs_buf_islocked(bp) \
287
263
 	((bp)->b_sema.count <= 0)
288
264
 
265
+static inline void xfs_buf_relse(xfs_buf_t *bp)
266
+{
267
+	xfs_buf_unlock(bp);
268
+	xfs_buf_rele(bp);
269
+}
270
+
289
271
 /* Buffer Read and Write Routines */
290
272
 extern int xfs_bwrite(struct xfs_buf *bp);
291
-extern void xfs_buf_ioend(struct xfs_buf *bp);
273
+
292
274
 extern void __xfs_buf_ioerror(struct xfs_buf *bp, int error,
293
275
 		xfs_failaddr_t failaddr);
294
276
 #define xfs_buf_ioerror(bp, err) __xfs_buf_ioerror((bp), (err), __this_address)
295
-extern void xfs_buf_ioerror_alert(struct xfs_buf *, const char *func);
296
-
297
-extern int __xfs_buf_submit(struct xfs_buf *bp, bool);
298
-static inline int xfs_buf_submit(struct xfs_buf *bp)
299
-{
300
-	bool wait = bp->b_flags & XBF_ASYNC ? false : true;
301
-	return __xfs_buf_submit(bp, wait);
302
-}
303
-
304
-extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *,
305
-				xfs_buf_rw_t);
306
-#define xfs_buf_zero(bp, off, len) \
307
-	    xfs_buf_iomove((bp), (off), (len), NULL, XBRW_ZERO)
277
+extern void xfs_buf_ioerror_alert(struct xfs_buf *bp, xfs_failaddr_t fa);
278
+void xfs_buf_ioend_fail(struct xfs_buf *);
279
+void xfs_buf_zero(struct xfs_buf *bp, size_t boff, size_t bsize);
280
+void __xfs_buf_mark_corrupt(struct xfs_buf *bp, xfs_failaddr_t fa);
281
+#define xfs_buf_mark_corrupt(bp) __xfs_buf_mark_corrupt((bp), __this_address)
308
282
 
309
283
 /* Buffer Utility Routines */
310
284
 extern void *xfs_buf_offset(struct xfs_buf *, size_t);
..
..
@@ -353,12 +327,6 @@
353
327
 	return atomic_read(&bp->b_pin_count);
354
328
 }
355
329
 
356
-static inline void xfs_buf_relse(xfs_buf_t *bp)
357
-{
358
-	xfs_buf_unlock(bp);
359
-	xfs_buf_rele(bp);
360
-}
361
-
362
330
 static inline int
363
331
 xfs_buf_verify_cksum(struct xfs_buf *bp, unsigned long cksum_offset)
364
332
 {
..
..
@@ -385,4 +353,14 @@
385
353
 #define xfs_getsize_buftarg(buftarg)	block_size((buftarg)->bt_bdev)
386
354
 #define xfs_readonly_buftarg(buftarg)	bdev_read_only((buftarg)->bt_bdev)
387
355
 
356
+static inline int
357
+xfs_buftarg_dma_alignment(struct xfs_buftarg *bt)
358
+{
359
+	return queue_dma_alignment(bt->bt_bdev->bd_disk->queue);
360
+}
361
+
362
+int xfs_buf_reverify(struct xfs_buf *bp, const struct xfs_buf_ops *ops);
363
+bool xfs_verify_magic(struct xfs_buf *bp, __be32 dmagic);
364
+bool xfs_verify_magic16(struct xfs_buf *bp, __be16 dmagic);
365
+
388
366
 #endif	/* __XFS_BUF_H__ */