1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_types.h"
21#include "xfs_log.h"
22#include "xfs_trans.h"
23#include "xfs_buf_item.h"
24#include "xfs_sb.h"
25#include "xfs_ag.h"
26#include "xfs_mount.h"
27#include "xfs_trans_priv.h"
28#include "xfs_extfree_item.h"
29
30
31kmem_zone_t *xfs_efi_zone;
32kmem_zone_t *xfs_efd_zone;
33
34static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip)
35{
36 return container_of(lip, struct xfs_efi_log_item, efi_item);
37}
38
39void
40xfs_efi_item_free(
41 struct xfs_efi_log_item *efip)
42{
43 if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS)
44 kmem_free(efip);
45 else
46 kmem_zone_free(xfs_efi_zone, efip);
47}
48
49
50
51
52
53
54
55
56STATIC void
57__xfs_efi_release(
58 struct xfs_efi_log_item *efip)
59{
60 struct xfs_ail *ailp = efip->efi_item.li_ailp;
61
62 if (atomic_dec_and_test(&efip->efi_refcount)) {
63 spin_lock(&ailp->xa_lock);
64
65 xfs_trans_ail_delete(ailp, &efip->efi_item,
66 SHUTDOWN_LOG_IO_ERROR);
67 xfs_efi_item_free(efip);
68 }
69}
70
71
72
73
74
75
76STATIC uint
77xfs_efi_item_size(
78 struct xfs_log_item *lip)
79{
80 return 1;
81}
82
83
84
85
86
87
88
89
90STATIC void
91xfs_efi_item_format(
92 struct xfs_log_item *lip,
93 struct xfs_log_iovec *log_vector)
94{
95 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
96 uint size;
97
98 ASSERT(atomic_read(&efip->efi_next_extent) ==
99 efip->efi_format.efi_nextents);
100
101 efip->efi_format.efi_type = XFS_LI_EFI;
102
103 size = sizeof(xfs_efi_log_format_t);
104 size += (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t);
105 efip->efi_format.efi_size = 1;
106
107 log_vector->i_addr = &efip->efi_format;
108 log_vector->i_len = size;
109 log_vector->i_type = XLOG_REG_TYPE_EFI_FORMAT;
110 ASSERT(size >= sizeof(xfs_efi_log_format_t));
111}
112
113
114
115
116
117STATIC void
118xfs_efi_item_pin(
119 struct xfs_log_item *lip)
120{
121}
122
123
124
125
126
127
128
129
130
131STATIC void
132xfs_efi_item_unpin(
133 struct xfs_log_item *lip,
134 int remove)
135{
136 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
137
138 if (remove) {
139 ASSERT(!(lip->li_flags & XFS_LI_IN_AIL));
140 if (lip->li_desc)
141 xfs_trans_del_item(lip);
142 xfs_efi_item_free(efip);
143 return;
144 }
145 __xfs_efi_release(efip);
146}
147
148
149
150
151
152
153
154
155STATIC uint
156xfs_efi_item_push(
157 struct xfs_log_item *lip,
158 struct list_head *buffer_list)
159{
160 return XFS_ITEM_PINNED;
161}
162
163STATIC void
164xfs_efi_item_unlock(
165 struct xfs_log_item *lip)
166{
167 if (lip->li_flags & XFS_LI_ABORTED)
168 xfs_efi_item_free(EFI_ITEM(lip));
169}
170
171
172
173
174
175STATIC xfs_lsn_t
176xfs_efi_item_committed(
177 struct xfs_log_item *lip,
178 xfs_lsn_t lsn)
179{
180 return lsn;
181}
182
183
184
185
186
187
188
189
190STATIC void
191xfs_efi_item_committing(
192 struct xfs_log_item *lip,
193 xfs_lsn_t lsn)
194{
195}
196
197
198
199
200static const struct xfs_item_ops xfs_efi_item_ops = {
201 .iop_size = xfs_efi_item_size,
202 .iop_format = xfs_efi_item_format,
203 .iop_pin = xfs_efi_item_pin,
204 .iop_unpin = xfs_efi_item_unpin,
205 .iop_unlock = xfs_efi_item_unlock,
206 .iop_committed = xfs_efi_item_committed,
207 .iop_push = xfs_efi_item_push,
208 .iop_committing = xfs_efi_item_committing
209};
210
211
212
213
214
215struct xfs_efi_log_item *
216xfs_efi_init(
217 struct xfs_mount *mp,
218 uint nextents)
219
220{
221 struct xfs_efi_log_item *efip;
222 uint size;
223
224 ASSERT(nextents > 0);
225 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
226 size = (uint)(sizeof(xfs_efi_log_item_t) +
227 ((nextents - 1) * sizeof(xfs_extent_t)));
228 efip = kmem_zalloc(size, KM_SLEEP);
229 } else {
230 efip = kmem_zone_zalloc(xfs_efi_zone, KM_SLEEP);
231 }
232
233 xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops);
234 efip->efi_format.efi_nextents = nextents;
235 efip->efi_format.efi_id = (__psint_t)(void*)efip;
236 atomic_set(&efip->efi_next_extent, 0);
237 atomic_set(&efip->efi_refcount, 2);
238
239 return efip;
240}
241
242
243
244
245
246
247
248
249int
250xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
251{
252 xfs_efi_log_format_t *src_efi_fmt = buf->i_addr;
253 uint i;
254 uint len = sizeof(xfs_efi_log_format_t) +
255 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t);
256 uint len32 = sizeof(xfs_efi_log_format_32_t) +
257 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t);
258 uint len64 = sizeof(xfs_efi_log_format_64_t) +
259 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t);
260
261 if (buf->i_len == len) {
262 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len);
263 return 0;
264 } else if (buf->i_len == len32) {
265 xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr;
266
267 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type;
268 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size;
269 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
270 dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id;
271 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
272 dst_efi_fmt->efi_extents[i].ext_start =
273 src_efi_fmt_32->efi_extents[i].ext_start;
274 dst_efi_fmt->efi_extents[i].ext_len =
275 src_efi_fmt_32->efi_extents[i].ext_len;
276 }
277 return 0;
278 } else if (buf->i_len == len64) {
279 xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr;
280
281 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type;
282 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size;
283 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
284 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id;
285 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
286 dst_efi_fmt->efi_extents[i].ext_start =
287 src_efi_fmt_64->efi_extents[i].ext_start;
288 dst_efi_fmt->efi_extents[i].ext_len =
289 src_efi_fmt_64->efi_extents[i].ext_len;
290 }
291 return 0;
292 }
293 return EFSCORRUPTED;
294}
295
296
297
298
299
300
301
302void
303xfs_efi_release(xfs_efi_log_item_t *efip,
304 uint nextents)
305{
306 ASSERT(atomic_read(&efip->efi_next_extent) >= nextents);
307 if (atomic_sub_and_test(nextents, &efip->efi_next_extent)) {
308
309 if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags))
310 __xfs_efi_release(efip);
311
312 __xfs_efi_release(efip);
313
314 }
315}
316
317static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip)
318{
319 return container_of(lip, struct xfs_efd_log_item, efd_item);
320}
321
322STATIC void
323xfs_efd_item_free(struct xfs_efd_log_item *efdp)
324{
325 if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS)
326 kmem_free(efdp);
327 else
328 kmem_zone_free(xfs_efd_zone, efdp);
329}
330
331
332
333
334
335
336STATIC uint
337xfs_efd_item_size(
338 struct xfs_log_item *lip)
339{
340 return 1;
341}
342
343
344
345
346
347
348
349
350STATIC void
351xfs_efd_item_format(
352 struct xfs_log_item *lip,
353 struct xfs_log_iovec *log_vector)
354{
355 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
356 uint size;
357
358 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
359
360 efdp->efd_format.efd_type = XFS_LI_EFD;
361
362 size = sizeof(xfs_efd_log_format_t);
363 size += (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);
364 efdp->efd_format.efd_size = 1;
365
366 log_vector->i_addr = &efdp->efd_format;
367 log_vector->i_len = size;
368 log_vector->i_type = XLOG_REG_TYPE_EFD_FORMAT;
369 ASSERT(size >= sizeof(xfs_efd_log_format_t));
370}
371
372
373
374
375STATIC void
376xfs_efd_item_pin(
377 struct xfs_log_item *lip)
378{
379}
380
381
382
383
384
385STATIC void
386xfs_efd_item_unpin(
387 struct xfs_log_item *lip,
388 int remove)
389{
390}
391
392
393
394
395
396STATIC uint
397xfs_efd_item_push(
398 struct xfs_log_item *lip,
399 struct list_head *buffer_list)
400{
401 return XFS_ITEM_PINNED;
402}
403
404STATIC void
405xfs_efd_item_unlock(
406 struct xfs_log_item *lip)
407{
408 if (lip->li_flags & XFS_LI_ABORTED)
409 xfs_efd_item_free(EFD_ITEM(lip));
410}
411
412
413
414
415
416
417
418
419STATIC xfs_lsn_t
420xfs_efd_item_committed(
421 struct xfs_log_item *lip,
422 xfs_lsn_t lsn)
423{
424 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
425
426
427
428
429
430 if (!(lip->li_flags & XFS_LI_ABORTED))
431 xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents);
432
433 xfs_efd_item_free(efdp);
434 return (xfs_lsn_t)-1;
435}
436
437
438
439
440
441
442
443
444STATIC void
445xfs_efd_item_committing(
446 struct xfs_log_item *lip,
447 xfs_lsn_t lsn)
448{
449}
450
451
452
453
454static const struct xfs_item_ops xfs_efd_item_ops = {
455 .iop_size = xfs_efd_item_size,
456 .iop_format = xfs_efd_item_format,
457 .iop_pin = xfs_efd_item_pin,
458 .iop_unpin = xfs_efd_item_unpin,
459 .iop_unlock = xfs_efd_item_unlock,
460 .iop_committed = xfs_efd_item_committed,
461 .iop_push = xfs_efd_item_push,
462 .iop_committing = xfs_efd_item_committing
463};
464
465
466
467
468struct xfs_efd_log_item *
469xfs_efd_init(
470 struct xfs_mount *mp,
471 struct xfs_efi_log_item *efip,
472 uint nextents)
473
474{
475 struct xfs_efd_log_item *efdp;
476 uint size;
477
478 ASSERT(nextents > 0);
479 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) {
480 size = (uint)(sizeof(xfs_efd_log_item_t) +
481 ((nextents - 1) * sizeof(xfs_extent_t)));
482 efdp = kmem_zalloc(size, KM_SLEEP);
483 } else {
484 efdp = kmem_zone_zalloc(xfs_efd_zone, KM_SLEEP);
485 }
486
487 xfs_log_item_init(mp, &efdp->efd_item, XFS_LI_EFD, &xfs_efd_item_ops);
488 efdp->efd_efip = efip;
489 efdp->efd_format.efd_nextents = nextents;
490 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
491
492 return efdp;
493}
494