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