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_inum.h"
23#include "xfs_trans.h"
24#include "xfs_buf_item.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
27#include "xfs_dmapi.h"
28#include "xfs_mount.h"
29#include "xfs_trans_priv.h"
30#include "xfs_extfree_item.h"
31
32
33kmem_zone_t *xfs_efi_zone;
34kmem_zone_t *xfs_efd_zone;
35
36STATIC void xfs_efi_item_unlock(xfs_efi_log_item_t *);
37
38void
39xfs_efi_item_free(xfs_efi_log_item_t *efip)
40{
41 int nexts = efip->efi_format.efi_nextents;
42
43 if (nexts > 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 uint
57xfs_efi_item_size(xfs_efi_log_item_t *efip)
58{
59 return 1;
60}
61
62
63
64
65
66
67
68
69STATIC void
70xfs_efi_item_format(xfs_efi_log_item_t *efip,
71 xfs_log_iovec_t *log_vector)
72{
73 uint size;
74
75 ASSERT(efip->efi_next_extent == efip->efi_format.efi_nextents);
76
77 efip->efi_format.efi_type = XFS_LI_EFI;
78
79 size = sizeof(xfs_efi_log_format_t);
80 size += (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t);
81 efip->efi_format.efi_size = 1;
82
83 log_vector->i_addr = (xfs_caddr_t)&(efip->efi_format);
84 log_vector->i_len = size;
85 XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_EFI_FORMAT);
86 ASSERT(size >= sizeof(xfs_efi_log_format_t));
87}
88
89
90
91
92
93
94STATIC void
95xfs_efi_item_pin(xfs_efi_log_item_t *efip)
96{
97 return;
98}
99
100
101
102
103
104
105
106
107
108STATIC void
109xfs_efi_item_unpin(xfs_efi_log_item_t *efip, int stale)
110{
111 xfs_mount_t *mp;
112
113 mp = efip->efi_item.li_mountp;
114 spin_lock(&mp->m_ail_lock);
115 if (efip->efi_flags & XFS_EFI_CANCELED) {
116
117
118
119 xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip);
120 xfs_efi_item_free(efip);
121 } else {
122 efip->efi_flags |= XFS_EFI_COMMITTED;
123 spin_unlock(&mp->m_ail_lock);
124 }
125}
126
127
128
129
130
131
132
133
134STATIC void
135xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, xfs_trans_t *tp)
136{
137 xfs_mount_t *mp;
138 xfs_log_item_desc_t *lidp;
139
140 mp = efip->efi_item.li_mountp;
141 spin_lock(&mp->m_ail_lock);
142 if (efip->efi_flags & XFS_EFI_CANCELED) {
143
144
145
146 lidp = xfs_trans_find_item(tp, (xfs_log_item_t *) efip);
147 xfs_trans_free_item(tp, lidp);
148
149
150
151
152 xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip);
153 xfs_efi_item_free(efip);
154 } else {
155 efip->efi_flags |= XFS_EFI_COMMITTED;
156 spin_unlock(&mp->m_ail_lock);
157 }
158}
159
160
161
162
163
164
165
166
167
168STATIC uint
169xfs_efi_item_trylock(xfs_efi_log_item_t *efip)
170{
171 return XFS_ITEM_PINNED;
172}
173
174
175
176
177
178STATIC void
179xfs_efi_item_unlock(xfs_efi_log_item_t *efip)
180{
181 if (efip->efi_item.li_flags & XFS_LI_ABORTED)
182 xfs_efi_item_free(efip);
183 return;
184}
185
186
187
188
189
190
191
192
193STATIC xfs_lsn_t
194xfs_efi_item_committed(xfs_efi_log_item_t *efip, xfs_lsn_t lsn)
195{
196 return lsn;
197}
198
199
200
201
202
203
204
205STATIC void
206xfs_efi_item_push(xfs_efi_log_item_t *efip)
207{
208 return;
209}
210
211
212
213
214
215
216
217
218
219STATIC void
220xfs_efi_item_committing(xfs_efi_log_item_t *efip, xfs_lsn_t lsn)
221{
222 return;
223}
224
225
226
227
228static struct xfs_item_ops xfs_efi_item_ops = {
229 .iop_size = (uint(*)(xfs_log_item_t*))xfs_efi_item_size,
230 .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
231 xfs_efi_item_format,
232 .iop_pin = (void(*)(xfs_log_item_t*))xfs_efi_item_pin,
233 .iop_unpin = (void(*)(xfs_log_item_t*, int))xfs_efi_item_unpin,
234 .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t *))
235 xfs_efi_item_unpin_remove,
236 .iop_trylock = (uint(*)(xfs_log_item_t*))xfs_efi_item_trylock,
237 .iop_unlock = (void(*)(xfs_log_item_t*))xfs_efi_item_unlock,
238 .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
239 xfs_efi_item_committed,
240 .iop_push = (void(*)(xfs_log_item_t*))xfs_efi_item_push,
241 .iop_pushbuf = NULL,
242 .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
243 xfs_efi_item_committing
244};
245
246
247
248
249
250xfs_efi_log_item_t *
251xfs_efi_init(xfs_mount_t *mp,
252 uint nextents)
253
254{
255 xfs_efi_log_item_t *efip;
256 uint size;
257
258 ASSERT(nextents > 0);
259 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
260 size = (uint)(sizeof(xfs_efi_log_item_t) +
261 ((nextents - 1) * sizeof(xfs_extent_t)));
262 efip = (xfs_efi_log_item_t*)kmem_zalloc(size, KM_SLEEP);
263 } else {
264 efip = (xfs_efi_log_item_t*)kmem_zone_zalloc(xfs_efi_zone,
265 KM_SLEEP);
266 }
267
268 efip->efi_item.li_type = XFS_LI_EFI;
269 efip->efi_item.li_ops = &xfs_efi_item_ops;
270 efip->efi_item.li_mountp = mp;
271 efip->efi_format.efi_nextents = nextents;
272 efip->efi_format.efi_id = (__psint_t)(void*)efip;
273
274 return (efip);
275}
276
277
278
279
280
281
282
283
284int
285xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
286{
287 xfs_efi_log_format_t *src_efi_fmt = (xfs_efi_log_format_t *)buf->i_addr;
288 uint i;
289 uint len = sizeof(xfs_efi_log_format_t) +
290 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t);
291 uint len32 = sizeof(xfs_efi_log_format_32_t) +
292 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t);
293 uint len64 = sizeof(xfs_efi_log_format_64_t) +
294 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t);
295
296 if (buf->i_len == len) {
297 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len);
298 return 0;
299 } else if (buf->i_len == len32) {
300 xfs_efi_log_format_32_t *src_efi_fmt_32 =
301 (xfs_efi_log_format_32_t *)buf->i_addr;
302
303 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type;
304 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size;
305 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
306 dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id;
307 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
308 dst_efi_fmt->efi_extents[i].ext_start =
309 src_efi_fmt_32->efi_extents[i].ext_start;
310 dst_efi_fmt->efi_extents[i].ext_len =
311 src_efi_fmt_32->efi_extents[i].ext_len;
312 }
313 return 0;
314 } else if (buf->i_len == len64) {
315 xfs_efi_log_format_64_t *src_efi_fmt_64 =
316 (xfs_efi_log_format_64_t *)buf->i_addr;
317
318 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type;
319 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size;
320 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
321 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id;
322 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
323 dst_efi_fmt->efi_extents[i].ext_start =
324 src_efi_fmt_64->efi_extents[i].ext_start;
325 dst_efi_fmt->efi_extents[i].ext_len =
326 src_efi_fmt_64->efi_extents[i].ext_len;
327 }
328 return 0;
329 }
330 return EFSCORRUPTED;
331}
332
333
334
335
336
337
338
339
340
341
342
343
344void
345xfs_efi_release(xfs_efi_log_item_t *efip,
346 uint nextents)
347{
348 xfs_mount_t *mp;
349 int extents_left;
350
351 mp = efip->efi_item.li_mountp;
352 ASSERT(efip->efi_next_extent > 0);
353 ASSERT(efip->efi_flags & XFS_EFI_COMMITTED);
354
355 spin_lock(&mp->m_ail_lock);
356 ASSERT(efip->efi_next_extent >= nextents);
357 efip->efi_next_extent -= nextents;
358 extents_left = efip->efi_next_extent;
359 if (extents_left == 0) {
360
361
362
363 xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip);
364 xfs_efi_item_free(efip);
365 } else {
366 spin_unlock(&mp->m_ail_lock);
367 }
368}
369
370STATIC void
371xfs_efd_item_free(xfs_efd_log_item_t *efdp)
372{
373 int nexts = efdp->efd_format.efd_nextents;
374
375 if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
376 kmem_free(efdp);
377 } else {
378 kmem_zone_free(xfs_efd_zone, efdp);
379 }
380}
381
382
383
384
385
386
387
388STATIC uint
389xfs_efd_item_size(xfs_efd_log_item_t *efdp)
390{
391 return 1;
392}
393
394
395
396
397
398
399
400
401STATIC void
402xfs_efd_item_format(xfs_efd_log_item_t *efdp,
403 xfs_log_iovec_t *log_vector)
404{
405 uint size;
406
407 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
408
409 efdp->efd_format.efd_type = XFS_LI_EFD;
410
411 size = sizeof(xfs_efd_log_format_t);
412 size += (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);
413 efdp->efd_format.efd_size = 1;
414
415 log_vector->i_addr = (xfs_caddr_t)&(efdp->efd_format);
416 log_vector->i_len = size;
417 XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_EFD_FORMAT);
418 ASSERT(size >= sizeof(xfs_efd_log_format_t));
419}
420
421
422
423
424
425
426STATIC void
427xfs_efd_item_pin(xfs_efd_log_item_t *efdp)
428{
429 return;
430}
431
432
433
434
435
436
437
438STATIC void
439xfs_efd_item_unpin(xfs_efd_log_item_t *efdp, int stale)
440{
441 return;
442}
443
444
445STATIC void
446xfs_efd_item_unpin_remove(xfs_efd_log_item_t *efdp, xfs_trans_t *tp)
447{
448 return;
449}
450
451
452
453
454
455STATIC uint
456xfs_efd_item_trylock(xfs_efd_log_item_t *efdp)
457{
458 return XFS_ITEM_LOCKED;
459}
460
461
462
463
464
465
466STATIC void
467xfs_efd_item_unlock(xfs_efd_log_item_t *efdp)
468{
469 if (efdp->efd_item.li_flags & XFS_LI_ABORTED)
470 xfs_efd_item_free(efdp);
471 return;
472}
473
474
475
476
477
478
479
480
481
482STATIC xfs_lsn_t
483xfs_efd_item_committed(xfs_efd_log_item_t *efdp, xfs_lsn_t lsn)
484{
485
486
487
488
489 if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0)
490 xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents);
491
492 xfs_efd_item_free(efdp);
493 return (xfs_lsn_t)-1;
494}
495
496
497
498
499
500
501STATIC void
502xfs_efd_item_push(xfs_efd_log_item_t *efdp)
503{
504 return;
505}
506
507
508
509
510
511
512
513
514
515STATIC void
516xfs_efd_item_committing(xfs_efd_log_item_t *efip, xfs_lsn_t lsn)
517{
518 return;
519}
520
521
522
523
524static struct xfs_item_ops xfs_efd_item_ops = {
525 .iop_size = (uint(*)(xfs_log_item_t*))xfs_efd_item_size,
526 .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
527 xfs_efd_item_format,
528 .iop_pin = (void(*)(xfs_log_item_t*))xfs_efd_item_pin,
529 .iop_unpin = (void(*)(xfs_log_item_t*, int))xfs_efd_item_unpin,
530 .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t*))
531 xfs_efd_item_unpin_remove,
532 .iop_trylock = (uint(*)(xfs_log_item_t*))xfs_efd_item_trylock,
533 .iop_unlock = (void(*)(xfs_log_item_t*))xfs_efd_item_unlock,
534 .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
535 xfs_efd_item_committed,
536 .iop_push = (void(*)(xfs_log_item_t*))xfs_efd_item_push,
537 .iop_pushbuf = NULL,
538 .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
539 xfs_efd_item_committing
540};
541
542
543
544
545
546xfs_efd_log_item_t *
547xfs_efd_init(xfs_mount_t *mp,
548 xfs_efi_log_item_t *efip,
549 uint nextents)
550
551{
552 xfs_efd_log_item_t *efdp;
553 uint size;
554
555 ASSERT(nextents > 0);
556 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) {
557 size = (uint)(sizeof(xfs_efd_log_item_t) +
558 ((nextents - 1) * sizeof(xfs_extent_t)));
559 efdp = (xfs_efd_log_item_t*)kmem_zalloc(size, KM_SLEEP);
560 } else {
561 efdp = (xfs_efd_log_item_t*)kmem_zone_zalloc(xfs_efd_zone,
562 KM_SLEEP);
563 }
564
565 efdp->efd_item.li_type = XFS_LI_EFD;
566 efdp->efd_item.li_ops = &xfs_efd_item_ops;
567 efdp->efd_item.li_mountp = mp;
568 efdp->efd_efip = efip;
569 efdp->efd_format.efd_nextents = nextents;
570 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
571
572 return (efdp);
573}