This source file includes following definitions.
- INODE_ITEM
- xfs_inode_item_data_fork_size
- xfs_inode_item_attr_fork_size
- xfs_inode_item_size
- xfs_inode_item_format_data_fork
- xfs_inode_item_format_attr_fork
- xfs_inode_to_log_dinode
- xfs_inode_item_format_core
- xfs_inode_item_format
- xfs_inode_item_pin
- xfs_inode_item_unpin
- xfs_inode_item_error
- xfs_inode_item_push
- xfs_inode_item_release
- xfs_inode_item_committed
- xfs_inode_item_committing
- xfs_inode_item_init
- xfs_inode_item_destroy
- xfs_iflush_done
- xfs_iflush_abort
- xfs_istale_done
- xfs_inode_item_format_convert
1
2
3
4
5
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_inode.h"
14 #include "xfs_trans.h"
15 #include "xfs_inode_item.h"
16 #include "xfs_trace.h"
17 #include "xfs_trans_priv.h"
18 #include "xfs_buf_item.h"
19 #include "xfs_log.h"
20
21 #include <linux/iversion.h>
22
23 kmem_zone_t *xfs_ili_zone;
24
25 static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip)
26 {
27 return container_of(lip, struct xfs_inode_log_item, ili_item);
28 }
29
30 STATIC void
31 xfs_inode_item_data_fork_size(
32 struct xfs_inode_log_item *iip,
33 int *nvecs,
34 int *nbytes)
35 {
36 struct xfs_inode *ip = iip->ili_inode;
37
38 switch (ip->i_d.di_format) {
39 case XFS_DINODE_FMT_EXTENTS:
40 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
41 ip->i_d.di_nextents > 0 &&
42 ip->i_df.if_bytes > 0) {
43
44 *nbytes += XFS_IFORK_DSIZE(ip);
45 *nvecs += 1;
46 }
47 break;
48 case XFS_DINODE_FMT_BTREE:
49 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
50 ip->i_df.if_broot_bytes > 0) {
51 *nbytes += ip->i_df.if_broot_bytes;
52 *nvecs += 1;
53 }
54 break;
55 case XFS_DINODE_FMT_LOCAL:
56 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
57 ip->i_df.if_bytes > 0) {
58 *nbytes += roundup(ip->i_df.if_bytes, 4);
59 *nvecs += 1;
60 }
61 break;
62
63 case XFS_DINODE_FMT_DEV:
64 break;
65 default:
66 ASSERT(0);
67 break;
68 }
69 }
70
71 STATIC void
72 xfs_inode_item_attr_fork_size(
73 struct xfs_inode_log_item *iip,
74 int *nvecs,
75 int *nbytes)
76 {
77 struct xfs_inode *ip = iip->ili_inode;
78
79 switch (ip->i_d.di_aformat) {
80 case XFS_DINODE_FMT_EXTENTS:
81 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
82 ip->i_d.di_anextents > 0 &&
83 ip->i_afp->if_bytes > 0) {
84
85 *nbytes += XFS_IFORK_ASIZE(ip);
86 *nvecs += 1;
87 }
88 break;
89 case XFS_DINODE_FMT_BTREE:
90 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
91 ip->i_afp->if_broot_bytes > 0) {
92 *nbytes += ip->i_afp->if_broot_bytes;
93 *nvecs += 1;
94 }
95 break;
96 case XFS_DINODE_FMT_LOCAL:
97 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
98 ip->i_afp->if_bytes > 0) {
99 *nbytes += roundup(ip->i_afp->if_bytes, 4);
100 *nvecs += 1;
101 }
102 break;
103 default:
104 ASSERT(0);
105 break;
106 }
107 }
108
109
110
111
112
113
114
115
116 STATIC void
117 xfs_inode_item_size(
118 struct xfs_log_item *lip,
119 int *nvecs,
120 int *nbytes)
121 {
122 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
123 struct xfs_inode *ip = iip->ili_inode;
124
125 *nvecs += 2;
126 *nbytes += sizeof(struct xfs_inode_log_format) +
127 xfs_log_dinode_size(ip->i_d.di_version);
128
129 xfs_inode_item_data_fork_size(iip, nvecs, nbytes);
130 if (XFS_IFORK_Q(ip))
131 xfs_inode_item_attr_fork_size(iip, nvecs, nbytes);
132 }
133
134 STATIC void
135 xfs_inode_item_format_data_fork(
136 struct xfs_inode_log_item *iip,
137 struct xfs_inode_log_format *ilf,
138 struct xfs_log_vec *lv,
139 struct xfs_log_iovec **vecp)
140 {
141 struct xfs_inode *ip = iip->ili_inode;
142 size_t data_bytes;
143
144 switch (ip->i_d.di_format) {
145 case XFS_DINODE_FMT_EXTENTS:
146 iip->ili_fields &=
147 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEV);
148
149 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
150 ip->i_d.di_nextents > 0 &&
151 ip->i_df.if_bytes > 0) {
152 struct xfs_bmbt_rec *p;
153
154 ASSERT(xfs_iext_count(&ip->i_df) > 0);
155
156 p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IEXT);
157 data_bytes = xfs_iextents_copy(ip, p, XFS_DATA_FORK);
158 xlog_finish_iovec(lv, *vecp, data_bytes);
159
160 ASSERT(data_bytes <= ip->i_df.if_bytes);
161
162 ilf->ilf_dsize = data_bytes;
163 ilf->ilf_size++;
164 } else {
165 iip->ili_fields &= ~XFS_ILOG_DEXT;
166 }
167 break;
168 case XFS_DINODE_FMT_BTREE:
169 iip->ili_fields &=
170 ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT | XFS_ILOG_DEV);
171
172 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
173 ip->i_df.if_broot_bytes > 0) {
174 ASSERT(ip->i_df.if_broot != NULL);
175 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IBROOT,
176 ip->i_df.if_broot,
177 ip->i_df.if_broot_bytes);
178 ilf->ilf_dsize = ip->i_df.if_broot_bytes;
179 ilf->ilf_size++;
180 } else {
181 ASSERT(!(iip->ili_fields &
182 XFS_ILOG_DBROOT));
183 iip->ili_fields &= ~XFS_ILOG_DBROOT;
184 }
185 break;
186 case XFS_DINODE_FMT_LOCAL:
187 iip->ili_fields &=
188 ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT | XFS_ILOG_DEV);
189 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
190 ip->i_df.if_bytes > 0) {
191
192
193
194
195
196 data_bytes = roundup(ip->i_df.if_bytes, 4);
197 ASSERT(ip->i_df.if_u1.if_data != NULL);
198 ASSERT(ip->i_d.di_size > 0);
199 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_ILOCAL,
200 ip->i_df.if_u1.if_data, data_bytes);
201 ilf->ilf_dsize = (unsigned)data_bytes;
202 ilf->ilf_size++;
203 } else {
204 iip->ili_fields &= ~XFS_ILOG_DDATA;
205 }
206 break;
207 case XFS_DINODE_FMT_DEV:
208 iip->ili_fields &=
209 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT | XFS_ILOG_DEXT);
210 if (iip->ili_fields & XFS_ILOG_DEV)
211 ilf->ilf_u.ilfu_rdev = sysv_encode_dev(VFS_I(ip)->i_rdev);
212 break;
213 default:
214 ASSERT(0);
215 break;
216 }
217 }
218
219 STATIC void
220 xfs_inode_item_format_attr_fork(
221 struct xfs_inode_log_item *iip,
222 struct xfs_inode_log_format *ilf,
223 struct xfs_log_vec *lv,
224 struct xfs_log_iovec **vecp)
225 {
226 struct xfs_inode *ip = iip->ili_inode;
227 size_t data_bytes;
228
229 switch (ip->i_d.di_aformat) {
230 case XFS_DINODE_FMT_EXTENTS:
231 iip->ili_fields &=
232 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
233
234 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
235 ip->i_d.di_anextents > 0 &&
236 ip->i_afp->if_bytes > 0) {
237 struct xfs_bmbt_rec *p;
238
239 ASSERT(xfs_iext_count(ip->i_afp) ==
240 ip->i_d.di_anextents);
241
242 p = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_EXT);
243 data_bytes = xfs_iextents_copy(ip, p, XFS_ATTR_FORK);
244 xlog_finish_iovec(lv, *vecp, data_bytes);
245
246 ilf->ilf_asize = data_bytes;
247 ilf->ilf_size++;
248 } else {
249 iip->ili_fields &= ~XFS_ILOG_AEXT;
250 }
251 break;
252 case XFS_DINODE_FMT_BTREE:
253 iip->ili_fields &=
254 ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
255
256 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
257 ip->i_afp->if_broot_bytes > 0) {
258 ASSERT(ip->i_afp->if_broot != NULL);
259
260 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_BROOT,
261 ip->i_afp->if_broot,
262 ip->i_afp->if_broot_bytes);
263 ilf->ilf_asize = ip->i_afp->if_broot_bytes;
264 ilf->ilf_size++;
265 } else {
266 iip->ili_fields &= ~XFS_ILOG_ABROOT;
267 }
268 break;
269 case XFS_DINODE_FMT_LOCAL:
270 iip->ili_fields &=
271 ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
272
273 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
274 ip->i_afp->if_bytes > 0) {
275
276
277
278
279
280 data_bytes = roundup(ip->i_afp->if_bytes, 4);
281 ASSERT(ip->i_afp->if_u1.if_data != NULL);
282 xlog_copy_iovec(lv, vecp, XLOG_REG_TYPE_IATTR_LOCAL,
283 ip->i_afp->if_u1.if_data,
284 data_bytes);
285 ilf->ilf_asize = (unsigned)data_bytes;
286 ilf->ilf_size++;
287 } else {
288 iip->ili_fields &= ~XFS_ILOG_ADATA;
289 }
290 break;
291 default:
292 ASSERT(0);
293 break;
294 }
295 }
296
297 static void
298 xfs_inode_to_log_dinode(
299 struct xfs_inode *ip,
300 struct xfs_log_dinode *to,
301 xfs_lsn_t lsn)
302 {
303 struct xfs_icdinode *from = &ip->i_d;
304 struct inode *inode = VFS_I(ip);
305
306 to->di_magic = XFS_DINODE_MAGIC;
307
308 to->di_version = from->di_version;
309 to->di_format = from->di_format;
310 to->di_uid = from->di_uid;
311 to->di_gid = from->di_gid;
312 to->di_projid_lo = from->di_projid_lo;
313 to->di_projid_hi = from->di_projid_hi;
314
315 memset(to->di_pad, 0, sizeof(to->di_pad));
316 memset(to->di_pad3, 0, sizeof(to->di_pad3));
317 to->di_atime.t_sec = inode->i_atime.tv_sec;
318 to->di_atime.t_nsec = inode->i_atime.tv_nsec;
319 to->di_mtime.t_sec = inode->i_mtime.tv_sec;
320 to->di_mtime.t_nsec = inode->i_mtime.tv_nsec;
321 to->di_ctime.t_sec = inode->i_ctime.tv_sec;
322 to->di_ctime.t_nsec = inode->i_ctime.tv_nsec;
323 to->di_nlink = inode->i_nlink;
324 to->di_gen = inode->i_generation;
325 to->di_mode = inode->i_mode;
326
327 to->di_size = from->di_size;
328 to->di_nblocks = from->di_nblocks;
329 to->di_extsize = from->di_extsize;
330 to->di_nextents = from->di_nextents;
331 to->di_anextents = from->di_anextents;
332 to->di_forkoff = from->di_forkoff;
333 to->di_aformat = from->di_aformat;
334 to->di_dmevmask = from->di_dmevmask;
335 to->di_dmstate = from->di_dmstate;
336 to->di_flags = from->di_flags;
337
338
339 to->di_next_unlinked = NULLAGINO;
340
341 if (from->di_version == 3) {
342 to->di_changecount = inode_peek_iversion(inode);
343 to->di_crtime.t_sec = from->di_crtime.t_sec;
344 to->di_crtime.t_nsec = from->di_crtime.t_nsec;
345 to->di_flags2 = from->di_flags2;
346 to->di_cowextsize = from->di_cowextsize;
347 to->di_ino = ip->i_ino;
348 to->di_lsn = lsn;
349 memset(to->di_pad2, 0, sizeof(to->di_pad2));
350 uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
351 to->di_flushiter = 0;
352 } else {
353 to->di_flushiter = from->di_flushiter;
354 }
355 }
356
357
358
359
360
361
362 static void
363 xfs_inode_item_format_core(
364 struct xfs_inode *ip,
365 struct xfs_log_vec *lv,
366 struct xfs_log_iovec **vecp)
367 {
368 struct xfs_log_dinode *dic;
369
370 dic = xlog_prepare_iovec(lv, vecp, XLOG_REG_TYPE_ICORE);
371 xfs_inode_to_log_dinode(ip, dic, ip->i_itemp->ili_item.li_lsn);
372 xlog_finish_iovec(lv, *vecp, xfs_log_dinode_size(ip->i_d.di_version));
373 }
374
375
376
377
378
379
380
381
382
383
384
385
386
387 STATIC void
388 xfs_inode_item_format(
389 struct xfs_log_item *lip,
390 struct xfs_log_vec *lv)
391 {
392 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
393 struct xfs_inode *ip = iip->ili_inode;
394 struct xfs_log_iovec *vecp = NULL;
395 struct xfs_inode_log_format *ilf;
396
397 ASSERT(ip->i_d.di_version > 1);
398
399 ilf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_IFORMAT);
400 ilf->ilf_type = XFS_LI_INODE;
401 ilf->ilf_ino = ip->i_ino;
402 ilf->ilf_blkno = ip->i_imap.im_blkno;
403 ilf->ilf_len = ip->i_imap.im_len;
404 ilf->ilf_boffset = ip->i_imap.im_boffset;
405 ilf->ilf_fields = XFS_ILOG_CORE;
406 ilf->ilf_size = 2;
407
408
409
410
411
412 ilf->ilf_dsize = 0;
413 ilf->ilf_asize = 0;
414 ilf->ilf_pad = 0;
415 memset(&ilf->ilf_u, 0, sizeof(ilf->ilf_u));
416
417 xlog_finish_iovec(lv, vecp, sizeof(*ilf));
418
419 xfs_inode_item_format_core(ip, lv, &vecp);
420 xfs_inode_item_format_data_fork(iip, ilf, lv, &vecp);
421 if (XFS_IFORK_Q(ip)) {
422 xfs_inode_item_format_attr_fork(iip, ilf, lv, &vecp);
423 } else {
424 iip->ili_fields &=
425 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT);
426 }
427
428
429 ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP);
430 }
431
432
433
434
435
436 STATIC void
437 xfs_inode_item_pin(
438 struct xfs_log_item *lip)
439 {
440 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
441
442 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
443
444 trace_xfs_inode_pin(ip, _RET_IP_);
445 atomic_inc(&ip->i_pincount);
446 }
447
448
449
450
451
452
453
454
455 STATIC void
456 xfs_inode_item_unpin(
457 struct xfs_log_item *lip,
458 int remove)
459 {
460 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
461
462 trace_xfs_inode_unpin(ip, _RET_IP_);
463 ASSERT(atomic_read(&ip->i_pincount) > 0);
464 if (atomic_dec_and_test(&ip->i_pincount))
465 wake_up_bit(&ip->i_flags, __XFS_IPINNED_BIT);
466 }
467
468
469
470
471
472
473
474
475
476 STATIC void
477 xfs_inode_item_error(
478 struct xfs_log_item *lip,
479 struct xfs_buf *bp)
480 {
481 ASSERT(xfs_isiflocked(INODE_ITEM(lip)->ili_inode));
482 xfs_set_li_failed(lip, bp);
483 }
484
485 STATIC uint
486 xfs_inode_item_push(
487 struct xfs_log_item *lip,
488 struct list_head *buffer_list)
489 __releases(&lip->li_ailp->ail_lock)
490 __acquires(&lip->li_ailp->ail_lock)
491 {
492 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
493 struct xfs_inode *ip = iip->ili_inode;
494 struct xfs_buf *bp = lip->li_buf;
495 uint rval = XFS_ITEM_SUCCESS;
496 int error;
497
498 if (xfs_ipincount(ip) > 0)
499 return XFS_ITEM_PINNED;
500
501
502
503
504
505 if (test_bit(XFS_LI_FAILED, &lip->li_flags)) {
506 if (!xfs_buf_trylock(bp))
507 return XFS_ITEM_LOCKED;
508
509 if (!xfs_buf_resubmit_failed_buffers(bp, buffer_list))
510 rval = XFS_ITEM_FLUSHING;
511
512 xfs_buf_unlock(bp);
513 return rval;
514 }
515
516 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
517 return XFS_ITEM_LOCKED;
518
519
520
521
522
523 if (xfs_ipincount(ip) > 0) {
524 rval = XFS_ITEM_PINNED;
525 goto out_unlock;
526 }
527
528
529
530
531 if (ip->i_flags & XFS_ISTALE) {
532 rval = XFS_ITEM_PINNED;
533 goto out_unlock;
534 }
535
536
537
538
539
540
541 if (!xfs_iflock_nowait(ip)) {
542 rval = XFS_ITEM_FLUSHING;
543 goto out_unlock;
544 }
545
546 ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
547 ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
548
549 spin_unlock(&lip->li_ailp->ail_lock);
550
551 error = xfs_iflush(ip, &bp);
552 if (!error) {
553 if (!xfs_buf_delwri_queue(bp, buffer_list))
554 rval = XFS_ITEM_FLUSHING;
555 xfs_buf_relse(bp);
556 }
557
558 spin_lock(&lip->li_ailp->ail_lock);
559 out_unlock:
560 xfs_iunlock(ip, XFS_ILOCK_SHARED);
561 return rval;
562 }
563
564
565
566
567 STATIC void
568 xfs_inode_item_release(
569 struct xfs_log_item *lip)
570 {
571 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
572 struct xfs_inode *ip = iip->ili_inode;
573 unsigned short lock_flags;
574
575 ASSERT(ip->i_itemp != NULL);
576 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
577
578 lock_flags = iip->ili_lock_flags;
579 iip->ili_lock_flags = 0;
580 if (lock_flags)
581 xfs_iunlock(ip, lock_flags);
582 }
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606 STATIC xfs_lsn_t
607 xfs_inode_item_committed(
608 struct xfs_log_item *lip,
609 xfs_lsn_t lsn)
610 {
611 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
612 struct xfs_inode *ip = iip->ili_inode;
613
614 if (xfs_iflags_test(ip, XFS_ISTALE)) {
615 xfs_inode_item_unpin(lip, 0);
616 return -1;
617 }
618 return lsn;
619 }
620
621 STATIC void
622 xfs_inode_item_committing(
623 struct xfs_log_item *lip,
624 xfs_lsn_t commit_lsn)
625 {
626 INODE_ITEM(lip)->ili_last_lsn = commit_lsn;
627 return xfs_inode_item_release(lip);
628 }
629
630 static const struct xfs_item_ops xfs_inode_item_ops = {
631 .iop_size = xfs_inode_item_size,
632 .iop_format = xfs_inode_item_format,
633 .iop_pin = xfs_inode_item_pin,
634 .iop_unpin = xfs_inode_item_unpin,
635 .iop_release = xfs_inode_item_release,
636 .iop_committed = xfs_inode_item_committed,
637 .iop_push = xfs_inode_item_push,
638 .iop_committing = xfs_inode_item_committing,
639 .iop_error = xfs_inode_item_error
640 };
641
642
643
644
645
646 void
647 xfs_inode_item_init(
648 struct xfs_inode *ip,
649 struct xfs_mount *mp)
650 {
651 struct xfs_inode_log_item *iip;
652
653 ASSERT(ip->i_itemp == NULL);
654 iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, 0);
655
656 iip->ili_inode = ip;
657 xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
658 &xfs_inode_item_ops);
659 }
660
661
662
663
664 void
665 xfs_inode_item_destroy(
666 xfs_inode_t *ip)
667 {
668 kmem_free(ip->i_itemp->ili_item.li_lv_shadow);
669 kmem_zone_free(xfs_ili_zone, ip->i_itemp);
670 }
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685 void
686 xfs_iflush_done(
687 struct xfs_buf *bp,
688 struct xfs_log_item *lip)
689 {
690 struct xfs_inode_log_item *iip;
691 struct xfs_log_item *blip, *n;
692 struct xfs_ail *ailp = lip->li_ailp;
693 int need_ail = 0;
694 LIST_HEAD(tmp);
695
696
697
698
699
700
701 list_add_tail(&lip->li_bio_list, &tmp);
702
703 list_for_each_entry_safe(blip, n, &bp->b_li_list, li_bio_list) {
704 if (lip->li_cb != xfs_iflush_done)
705 continue;
706
707 list_move_tail(&blip->li_bio_list, &tmp);
708
709
710
711
712 iip = INODE_ITEM(blip);
713 if ((iip->ili_logged && blip->li_lsn == iip->ili_flush_lsn) ||
714 test_bit(XFS_LI_FAILED, &blip->li_flags))
715 need_ail++;
716 }
717
718
719 iip = INODE_ITEM(lip);
720 if ((iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn) ||
721 test_bit(XFS_LI_FAILED, &lip->li_flags))
722 need_ail++;
723
724
725
726
727
728
729
730
731
732
733 if (need_ail) {
734 bool mlip_changed = false;
735
736
737 spin_lock(&ailp->ail_lock);
738 list_for_each_entry(blip, &tmp, li_bio_list) {
739 if (INODE_ITEM(blip)->ili_logged &&
740 blip->li_lsn == INODE_ITEM(blip)->ili_flush_lsn)
741 mlip_changed |= xfs_ail_delete_one(ailp, blip);
742 else {
743 xfs_clear_li_failed(blip);
744 }
745 }
746
747 if (mlip_changed) {
748 if (!XFS_FORCED_SHUTDOWN(ailp->ail_mount))
749 xlog_assign_tail_lsn_locked(ailp->ail_mount);
750 if (list_empty(&ailp->ail_head))
751 wake_up_all(&ailp->ail_empty);
752 }
753 spin_unlock(&ailp->ail_lock);
754
755 if (mlip_changed)
756 xfs_log_space_wake(ailp->ail_mount);
757 }
758
759
760
761
762
763
764 list_for_each_entry_safe(blip, n, &tmp, li_bio_list) {
765 list_del_init(&blip->li_bio_list);
766 iip = INODE_ITEM(blip);
767 iip->ili_logged = 0;
768 iip->ili_last_fields = 0;
769 xfs_ifunlock(iip->ili_inode);
770 }
771 list_del(&tmp);
772 }
773
774
775
776
777
778
779
780 void
781 xfs_iflush_abort(
782 xfs_inode_t *ip,
783 bool stale)
784 {
785 xfs_inode_log_item_t *iip = ip->i_itemp;
786
787 if (iip) {
788 if (test_bit(XFS_LI_IN_AIL, &iip->ili_item.li_flags)) {
789 xfs_trans_ail_remove(&iip->ili_item,
790 stale ? SHUTDOWN_LOG_IO_ERROR :
791 SHUTDOWN_CORRUPT_INCORE);
792 }
793 iip->ili_logged = 0;
794
795
796
797
798 iip->ili_last_fields = 0;
799
800
801
802
803 iip->ili_fields = 0;
804 iip->ili_fsync_fields = 0;
805 }
806
807
808
809 xfs_ifunlock(ip);
810 }
811
812 void
813 xfs_istale_done(
814 struct xfs_buf *bp,
815 struct xfs_log_item *lip)
816 {
817 xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
818 }
819
820
821
822
823
824 int
825 xfs_inode_item_format_convert(
826 struct xfs_log_iovec *buf,
827 struct xfs_inode_log_format *in_f)
828 {
829 struct xfs_inode_log_format_32 *in_f32 = buf->i_addr;
830
831 if (buf->i_len != sizeof(*in_f32))
832 return -EFSCORRUPTED;
833
834 in_f->ilf_type = in_f32->ilf_type;
835 in_f->ilf_size = in_f32->ilf_size;
836 in_f->ilf_fields = in_f32->ilf_fields;
837 in_f->ilf_asize = in_f32->ilf_asize;
838 in_f->ilf_dsize = in_f32->ilf_dsize;
839 in_f->ilf_ino = in_f32->ilf_ino;
840 memcpy(&in_f->ilf_u, &in_f32->ilf_u, sizeof(in_f->ilf_u));
841 in_f->ilf_blkno = in_f32->ilf_blkno;
842 in_f->ilf_len = in_f32->ilf_len;
843 in_f->ilf_boffset = in_f32->ilf_boffset;
844 return 0;
845 }