1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/log2.h>
19#include <linux/iversion.h>
20
21#include "xfs.h"
22#include "xfs_fs.h"
23#include "xfs_shared.h"
24#include "xfs_format.h"
25#include "xfs_log_format.h"
26#include "xfs_trans_resv.h"
27#include "xfs_sb.h"
28#include "xfs_mount.h"
29#include "xfs_defer.h"
30#include "xfs_inode.h"
31#include "xfs_da_format.h"
32#include "xfs_da_btree.h"
33#include "xfs_dir2.h"
34#include "xfs_attr_sf.h"
35#include "xfs_attr.h"
36#include "xfs_trans_space.h"
37#include "xfs_trans.h"
38#include "xfs_buf_item.h"
39#include "xfs_inode_item.h"
40#include "xfs_ialloc.h"
41#include "xfs_bmap.h"
42#include "xfs_bmap_util.h"
43#include "xfs_errortag.h"
44#include "xfs_error.h"
45#include "xfs_quota.h"
46#include "xfs_filestream.h"
47#include "xfs_cksum.h"
48#include "xfs_trace.h"
49#include "xfs_icache.h"
50#include "xfs_symlink.h"
51#include "xfs_trans_priv.h"
52#include "xfs_log.h"
53#include "xfs_bmap_btree.h"
54#include "xfs_reflink.h"
55#include "xfs_dir2_priv.h"
56
57kmem_zone_t *xfs_inode_zone;
58
59
60
61
62
63#define XFS_ITRUNC_MAX_EXTENTS 2
64
65STATIC int xfs_iflush_int(struct xfs_inode *, struct xfs_buf *);
66STATIC int xfs_iunlink(struct xfs_trans *, struct xfs_inode *);
67STATIC int xfs_iunlink_remove(struct xfs_trans *, struct xfs_inode *);
68
69
70
71
72xfs_extlen_t
73xfs_get_extsz_hint(
74 struct xfs_inode *ip)
75{
76 if ((ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE) && ip->i_d.di_extsize)
77 return ip->i_d.di_extsize;
78 if (XFS_IS_REALTIME_INODE(ip))
79 return ip->i_mount->m_sb.sb_rextsize;
80 return 0;
81}
82
83
84
85
86
87
88
89xfs_extlen_t
90xfs_get_cowextsz_hint(
91 struct xfs_inode *ip)
92{
93 xfs_extlen_t a, b;
94
95 a = 0;
96 if (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
97 a = ip->i_d.di_cowextsize;
98 b = xfs_get_extsz_hint(ip);
99
100 a = max(a, b);
101 if (a == 0)
102 return XFS_DEFAULT_COWEXTSZ_HINT;
103 return a;
104}
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121uint
122xfs_ilock_data_map_shared(
123 struct xfs_inode *ip)
124{
125 uint lock_mode = XFS_ILOCK_SHARED;
126
127 if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE &&
128 (ip->i_df.if_flags & XFS_IFEXTENTS) == 0)
129 lock_mode = XFS_ILOCK_EXCL;
130 xfs_ilock(ip, lock_mode);
131 return lock_mode;
132}
133
134uint
135xfs_ilock_attr_map_shared(
136 struct xfs_inode *ip)
137{
138 uint lock_mode = XFS_ILOCK_SHARED;
139
140 if (ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE &&
141 (ip->i_afp->if_flags & XFS_IFEXTENTS) == 0)
142 lock_mode = XFS_ILOCK_EXCL;
143 xfs_ilock(ip, lock_mode);
144 return lock_mode;
145}
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177void
178xfs_ilock(
179 xfs_inode_t *ip,
180 uint lock_flags)
181{
182 trace_xfs_ilock(ip, lock_flags, _RET_IP_);
183
184
185
186
187
188
189 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
190 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
191 ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
192 (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
193 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
194 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
195 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
196
197 if (lock_flags & XFS_IOLOCK_EXCL) {
198 down_write_nested(&VFS_I(ip)->i_rwsem,
199 XFS_IOLOCK_DEP(lock_flags));
200 } else if (lock_flags & XFS_IOLOCK_SHARED) {
201 down_read_nested(&VFS_I(ip)->i_rwsem,
202 XFS_IOLOCK_DEP(lock_flags));
203 }
204
205 if (lock_flags & XFS_MMAPLOCK_EXCL)
206 mrupdate_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
207 else if (lock_flags & XFS_MMAPLOCK_SHARED)
208 mraccess_nested(&ip->i_mmaplock, XFS_MMAPLOCK_DEP(lock_flags));
209
210 if (lock_flags & XFS_ILOCK_EXCL)
211 mrupdate_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
212 else if (lock_flags & XFS_ILOCK_SHARED)
213 mraccess_nested(&ip->i_lock, XFS_ILOCK_DEP(lock_flags));
214}
215
216
217
218
219
220
221
222
223
224
225
226
227
228int
229xfs_ilock_nowait(
230 xfs_inode_t *ip,
231 uint lock_flags)
232{
233 trace_xfs_ilock_nowait(ip, lock_flags, _RET_IP_);
234
235
236
237
238
239
240 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
241 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
242 ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
243 (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
244 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
245 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
246 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
247
248 if (lock_flags & XFS_IOLOCK_EXCL) {
249 if (!down_write_trylock(&VFS_I(ip)->i_rwsem))
250 goto out;
251 } else if (lock_flags & XFS_IOLOCK_SHARED) {
252 if (!down_read_trylock(&VFS_I(ip)->i_rwsem))
253 goto out;
254 }
255
256 if (lock_flags & XFS_MMAPLOCK_EXCL) {
257 if (!mrtryupdate(&ip->i_mmaplock))
258 goto out_undo_iolock;
259 } else if (lock_flags & XFS_MMAPLOCK_SHARED) {
260 if (!mrtryaccess(&ip->i_mmaplock))
261 goto out_undo_iolock;
262 }
263
264 if (lock_flags & XFS_ILOCK_EXCL) {
265 if (!mrtryupdate(&ip->i_lock))
266 goto out_undo_mmaplock;
267 } else if (lock_flags & XFS_ILOCK_SHARED) {
268 if (!mrtryaccess(&ip->i_lock))
269 goto out_undo_mmaplock;
270 }
271 return 1;
272
273out_undo_mmaplock:
274 if (lock_flags & XFS_MMAPLOCK_EXCL)
275 mrunlock_excl(&ip->i_mmaplock);
276 else if (lock_flags & XFS_MMAPLOCK_SHARED)
277 mrunlock_shared(&ip->i_mmaplock);
278out_undo_iolock:
279 if (lock_flags & XFS_IOLOCK_EXCL)
280 up_write(&VFS_I(ip)->i_rwsem);
281 else if (lock_flags & XFS_IOLOCK_SHARED)
282 up_read(&VFS_I(ip)->i_rwsem);
283out:
284 return 0;
285}
286
287
288
289
290
291
292
293
294
295
296
297
298
299void
300xfs_iunlock(
301 xfs_inode_t *ip,
302 uint lock_flags)
303{
304
305
306
307
308
309 ASSERT((lock_flags & (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL)) !=
310 (XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL));
311 ASSERT((lock_flags & (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL)) !=
312 (XFS_MMAPLOCK_SHARED | XFS_MMAPLOCK_EXCL));
313 ASSERT((lock_flags & (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL)) !=
314 (XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
315 ASSERT((lock_flags & ~(XFS_LOCK_MASK | XFS_LOCK_SUBCLASS_MASK)) == 0);
316 ASSERT(lock_flags != 0);
317
318 if (lock_flags & XFS_IOLOCK_EXCL)
319 up_write(&VFS_I(ip)->i_rwsem);
320 else if (lock_flags & XFS_IOLOCK_SHARED)
321 up_read(&VFS_I(ip)->i_rwsem);
322
323 if (lock_flags & XFS_MMAPLOCK_EXCL)
324 mrunlock_excl(&ip->i_mmaplock);
325 else if (lock_flags & XFS_MMAPLOCK_SHARED)
326 mrunlock_shared(&ip->i_mmaplock);
327
328 if (lock_flags & XFS_ILOCK_EXCL)
329 mrunlock_excl(&ip->i_lock);
330 else if (lock_flags & XFS_ILOCK_SHARED)
331 mrunlock_shared(&ip->i_lock);
332
333 trace_xfs_iunlock(ip, lock_flags, _RET_IP_);
334}
335
336
337
338
339
340void
341xfs_ilock_demote(
342 xfs_inode_t *ip,
343 uint lock_flags)
344{
345 ASSERT(lock_flags & (XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL));
346 ASSERT((lock_flags &
347 ~(XFS_IOLOCK_EXCL|XFS_MMAPLOCK_EXCL|XFS_ILOCK_EXCL)) == 0);
348
349 if (lock_flags & XFS_ILOCK_EXCL)
350 mrdemote(&ip->i_lock);
351 if (lock_flags & XFS_MMAPLOCK_EXCL)
352 mrdemote(&ip->i_mmaplock);
353 if (lock_flags & XFS_IOLOCK_EXCL)
354 downgrade_write(&VFS_I(ip)->i_rwsem);
355
356 trace_xfs_ilock_demote(ip, lock_flags, _RET_IP_);
357}
358
359#if defined(DEBUG) || defined(XFS_WARN)
360int
361xfs_isilocked(
362 xfs_inode_t *ip,
363 uint lock_flags)
364{
365 if (lock_flags & (XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)) {
366 if (!(lock_flags & XFS_ILOCK_SHARED))
367 return !!ip->i_lock.mr_writer;
368 return rwsem_is_locked(&ip->i_lock.mr_lock);
369 }
370
371 if (lock_flags & (XFS_MMAPLOCK_EXCL|XFS_MMAPLOCK_SHARED)) {
372 if (!(lock_flags & XFS_MMAPLOCK_SHARED))
373 return !!ip->i_mmaplock.mr_writer;
374 return rwsem_is_locked(&ip->i_mmaplock.mr_lock);
375 }
376
377 if (lock_flags & (XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED)) {
378 if (!(lock_flags & XFS_IOLOCK_SHARED))
379 return !debug_locks ||
380 lockdep_is_held_type(&VFS_I(ip)->i_rwsem, 0);
381 return rwsem_is_locked(&VFS_I(ip)->i_rwsem);
382 }
383
384 ASSERT(0);
385 return 0;
386}
387#endif
388
389
390
391
392
393
394
395#if (defined(DEBUG) || defined(XFS_WARN)) && defined(CONFIG_LOCKDEP)
396static bool
397xfs_lockdep_subclass_ok(
398 int subclass)
399{
400 return subclass < MAX_LOCKDEP_SUBCLASSES;
401}
402#else
403#define xfs_lockdep_subclass_ok(subclass) (true)
404#endif
405
406
407
408
409
410
411
412static inline int
413xfs_lock_inumorder(int lock_mode, int subclass)
414{
415 int class = 0;
416
417 ASSERT(!(lock_mode & (XFS_ILOCK_PARENT | XFS_ILOCK_RTBITMAP |
418 XFS_ILOCK_RTSUM)));
419 ASSERT(xfs_lockdep_subclass_ok(subclass));
420
421 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)) {
422 ASSERT(subclass <= XFS_IOLOCK_MAX_SUBCLASS);
423 class += subclass << XFS_IOLOCK_SHIFT;
424 }
425
426 if (lock_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) {
427 ASSERT(subclass <= XFS_MMAPLOCK_MAX_SUBCLASS);
428 class += subclass << XFS_MMAPLOCK_SHIFT;
429 }
430
431 if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) {
432 ASSERT(subclass <= XFS_ILOCK_MAX_SUBCLASS);
433 class += subclass << XFS_ILOCK_SHIFT;
434 }
435
436 return (lock_mode & ~XFS_LOCK_SUBCLASS_MASK) | class;
437}
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454static void
455xfs_lock_inodes(
456 xfs_inode_t **ips,
457 int inodes,
458 uint lock_mode)
459{
460 int attempts = 0, i, j, try_lock;
461 xfs_log_item_t *lp;
462
463
464
465
466
467
468
469
470 ASSERT(ips && inodes >= 2 && inodes <= 5);
471 ASSERT(lock_mode & (XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL |
472 XFS_ILOCK_EXCL));
473 ASSERT(!(lock_mode & (XFS_IOLOCK_SHARED | XFS_MMAPLOCK_SHARED |
474 XFS_ILOCK_SHARED)));
475 ASSERT(!(lock_mode & XFS_MMAPLOCK_EXCL) ||
476 inodes <= XFS_MMAPLOCK_MAX_SUBCLASS + 1);
477 ASSERT(!(lock_mode & XFS_ILOCK_EXCL) ||
478 inodes <= XFS_ILOCK_MAX_SUBCLASS + 1);
479
480 if (lock_mode & XFS_IOLOCK_EXCL) {
481 ASSERT(!(lock_mode & (XFS_MMAPLOCK_EXCL | XFS_ILOCK_EXCL)));
482 } else if (lock_mode & XFS_MMAPLOCK_EXCL)
483 ASSERT(!(lock_mode & XFS_ILOCK_EXCL));
484
485 try_lock = 0;
486 i = 0;
487again:
488 for (; i < inodes; i++) {
489 ASSERT(ips[i]);
490
491 if (i && (ips[i] == ips[i - 1]))
492 continue;
493
494
495
496
497
498 if (!try_lock) {
499 for (j = (i - 1); j >= 0 && !try_lock; j--) {
500 lp = (xfs_log_item_t *)ips[j]->i_itemp;
501 if (lp && (lp->li_flags & XFS_LI_IN_AIL))
502 try_lock++;
503 }
504 }
505
506
507
508
509
510
511
512 if (!try_lock) {
513 xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
514 continue;
515 }
516
517
518 ASSERT(i != 0);
519 if (xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i)))
520 continue;
521
522
523
524
525
526 attempts++;
527 for (j = i - 1; j >= 0; j--) {
528
529
530
531
532
533 if (j != (i - 1) && ips[j] == ips[j + 1])
534 continue;
535
536 xfs_iunlock(ips[j], lock_mode);
537 }
538
539 if ((attempts % 5) == 0) {
540 delay(1);
541 }
542 i = 0;
543 try_lock = 0;
544 goto again;
545 }
546}
547
548
549
550
551
552
553
554
555
556void
557xfs_lock_two_inodes(
558 struct xfs_inode *ip0,
559 uint ip0_mode,
560 struct xfs_inode *ip1,
561 uint ip1_mode)
562{
563 struct xfs_inode *temp;
564 uint mode_temp;
565 int attempts = 0;
566 xfs_log_item_t *lp;
567
568 ASSERT(hweight32(ip0_mode) == 1);
569 ASSERT(hweight32(ip1_mode) == 1);
570 ASSERT(!(ip0_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
571 ASSERT(!(ip1_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL)));
572 ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
573 !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
574 ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
575 !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
576 ASSERT(!(ip1_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
577 !(ip0_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
578 ASSERT(!(ip0_mode & (XFS_MMAPLOCK_SHARED|XFS_MMAPLOCK_EXCL)) ||
579 !(ip1_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)));
580
581 ASSERT(ip0->i_ino != ip1->i_ino);
582
583 if (ip0->i_ino > ip1->i_ino) {
584 temp = ip0;
585 ip0 = ip1;
586 ip1 = temp;
587 mode_temp = ip0_mode;
588 ip0_mode = ip1_mode;
589 ip1_mode = mode_temp;
590 }
591
592 again:
593 xfs_ilock(ip0, xfs_lock_inumorder(ip0_mode, 0));
594
595
596
597
598
599
600 lp = (xfs_log_item_t *)ip0->i_itemp;
601 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
602 if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(ip1_mode, 1))) {
603 xfs_iunlock(ip0, ip0_mode);
604 if ((++attempts % 5) == 0)
605 delay(1);
606 goto again;
607 }
608 } else {
609 xfs_ilock(ip1, xfs_lock_inumorder(ip1_mode, 1));
610 }
611}
612
613void
614__xfs_iflock(
615 struct xfs_inode *ip)
616{
617 wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IFLOCK_BIT);
618 DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IFLOCK_BIT);
619
620 do {
621 prepare_to_wait_exclusive(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
622 if (xfs_isiflocked(ip))
623 io_schedule();
624 } while (!xfs_iflock_nowait(ip));
625
626 finish_wait(wq, &wait.wq_entry);
627}
628
629STATIC uint
630_xfs_dic2xflags(
631 uint16_t di_flags,
632 uint64_t di_flags2,
633 bool has_attr)
634{
635 uint flags = 0;
636
637 if (di_flags & XFS_DIFLAG_ANY) {
638 if (di_flags & XFS_DIFLAG_REALTIME)
639 flags |= FS_XFLAG_REALTIME;
640 if (di_flags & XFS_DIFLAG_PREALLOC)
641 flags |= FS_XFLAG_PREALLOC;
642 if (di_flags & XFS_DIFLAG_IMMUTABLE)
643 flags |= FS_XFLAG_IMMUTABLE;
644 if (di_flags & XFS_DIFLAG_APPEND)
645 flags |= FS_XFLAG_APPEND;
646 if (di_flags & XFS_DIFLAG_SYNC)
647 flags |= FS_XFLAG_SYNC;
648 if (di_flags & XFS_DIFLAG_NOATIME)
649 flags |= FS_XFLAG_NOATIME;
650 if (di_flags & XFS_DIFLAG_NODUMP)
651 flags |= FS_XFLAG_NODUMP;
652 if (di_flags & XFS_DIFLAG_RTINHERIT)
653 flags |= FS_XFLAG_RTINHERIT;
654 if (di_flags & XFS_DIFLAG_PROJINHERIT)
655 flags |= FS_XFLAG_PROJINHERIT;
656 if (di_flags & XFS_DIFLAG_NOSYMLINKS)
657 flags |= FS_XFLAG_NOSYMLINKS;
658 if (di_flags & XFS_DIFLAG_EXTSIZE)
659 flags |= FS_XFLAG_EXTSIZE;
660 if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
661 flags |= FS_XFLAG_EXTSZINHERIT;
662 if (di_flags & XFS_DIFLAG_NODEFRAG)
663 flags |= FS_XFLAG_NODEFRAG;
664 if (di_flags & XFS_DIFLAG_FILESTREAM)
665 flags |= FS_XFLAG_FILESTREAM;
666 }
667
668 if (di_flags2 & XFS_DIFLAG2_ANY) {
669 if (di_flags2 & XFS_DIFLAG2_DAX)
670 flags |= FS_XFLAG_DAX;
671 if (di_flags2 & XFS_DIFLAG2_COWEXTSIZE)
672 flags |= FS_XFLAG_COWEXTSIZE;
673 }
674
675 if (has_attr)
676 flags |= FS_XFLAG_HASATTR;
677
678 return flags;
679}
680
681uint
682xfs_ip2xflags(
683 struct xfs_inode *ip)
684{
685 struct xfs_icdinode *dic = &ip->i_d;
686
687 return _xfs_dic2xflags(dic->di_flags, dic->di_flags2, XFS_IFORK_Q(ip));
688}
689
690
691
692
693
694
695
696int
697xfs_lookup(
698 xfs_inode_t *dp,
699 struct xfs_name *name,
700 xfs_inode_t **ipp,
701 struct xfs_name *ci_name)
702{
703 xfs_ino_t inum;
704 int error;
705
706 trace_xfs_lookup(dp, name);
707
708 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
709 return -EIO;
710
711 error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
712 if (error)
713 goto out_unlock;
714
715 error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
716 if (error)
717 goto out_free_name;
718
719 return 0;
720
721out_free_name:
722 if (ci_name)
723 kmem_free(ci_name->name);
724out_unlock:
725 *ipp = NULL;
726 return error;
727}
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760static int
761xfs_ialloc(
762 xfs_trans_t *tp,
763 xfs_inode_t *pip,
764 umode_t mode,
765 xfs_nlink_t nlink,
766 dev_t rdev,
767 prid_t prid,
768 xfs_buf_t **ialloc_context,
769 xfs_inode_t **ipp)
770{
771 struct xfs_mount *mp = tp->t_mountp;
772 xfs_ino_t ino;
773 xfs_inode_t *ip;
774 uint flags;
775 int error;
776 struct timespec tv;
777 struct inode *inode;
778
779
780
781
782
783 error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode,
784 ialloc_context, &ino);
785 if (error)
786 return error;
787 if (*ialloc_context || ino == NULLFSINO) {
788 *ipp = NULL;
789 return 0;
790 }
791 ASSERT(*ialloc_context == NULL);
792
793
794
795
796
797
798 error = xfs_iget(mp, tp, ino, XFS_IGET_CREATE,
799 XFS_ILOCK_EXCL, &ip);
800 if (error)
801 return error;
802 ASSERT(ip != NULL);
803 inode = VFS_I(ip);
804
805
806
807
808
809
810 if (ip->i_d.di_version == 1)
811 ip->i_d.di_version = 2;
812
813 inode->i_mode = mode;
814 set_nlink(inode, nlink);
815 ip->i_d.di_uid = xfs_kuid_to_uid(current_fsuid());
816 ip->i_d.di_gid = xfs_kgid_to_gid(current_fsgid());
817 inode->i_rdev = rdev;
818 xfs_set_projid(ip, prid);
819
820 if (pip && XFS_INHERIT_GID(pip)) {
821 ip->i_d.di_gid = pip->i_d.di_gid;
822 if ((VFS_I(pip)->i_mode & S_ISGID) && S_ISDIR(mode))
823 inode->i_mode |= S_ISGID;
824 }
825
826
827
828
829
830
831 if ((irix_sgid_inherit) &&
832 (inode->i_mode & S_ISGID) &&
833 (!in_group_p(xfs_gid_to_kgid(ip->i_d.di_gid))))
834 inode->i_mode &= ~S_ISGID;
835
836 ip->i_d.di_size = 0;
837 ip->i_d.di_nextents = 0;
838 ASSERT(ip->i_d.di_nblocks == 0);
839
840 tv = current_time(inode);
841 inode->i_mtime = tv;
842 inode->i_atime = tv;
843 inode->i_ctime = tv;
844
845 ip->i_d.di_extsize = 0;
846 ip->i_d.di_dmevmask = 0;
847 ip->i_d.di_dmstate = 0;
848 ip->i_d.di_flags = 0;
849
850 if (ip->i_d.di_version == 3) {
851 inode_set_iversion(inode, 1);
852 ip->i_d.di_flags2 = 0;
853 ip->i_d.di_cowextsize = 0;
854 ip->i_d.di_crtime.t_sec = (int32_t)tv.tv_sec;
855 ip->i_d.di_crtime.t_nsec = (int32_t)tv.tv_nsec;
856 }
857
858
859 flags = XFS_ILOG_CORE;
860 switch (mode & S_IFMT) {
861 case S_IFIFO:
862 case S_IFCHR:
863 case S_IFBLK:
864 case S_IFSOCK:
865 ip->i_d.di_format = XFS_DINODE_FMT_DEV;
866 ip->i_df.if_flags = 0;
867 flags |= XFS_ILOG_DEV;
868 break;
869 case S_IFREG:
870 case S_IFDIR:
871 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
872 uint di_flags = 0;
873
874 if (S_ISDIR(mode)) {
875 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
876 di_flags |= XFS_DIFLAG_RTINHERIT;
877 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
878 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
879 ip->i_d.di_extsize = pip->i_d.di_extsize;
880 }
881 if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
882 di_flags |= XFS_DIFLAG_PROJINHERIT;
883 } else if (S_ISREG(mode)) {
884 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
885 di_flags |= XFS_DIFLAG_REALTIME;
886 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
887 di_flags |= XFS_DIFLAG_EXTSIZE;
888 ip->i_d.di_extsize = pip->i_d.di_extsize;
889 }
890 }
891 if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
892 xfs_inherit_noatime)
893 di_flags |= XFS_DIFLAG_NOATIME;
894 if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
895 xfs_inherit_nodump)
896 di_flags |= XFS_DIFLAG_NODUMP;
897 if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
898 xfs_inherit_sync)
899 di_flags |= XFS_DIFLAG_SYNC;
900 if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
901 xfs_inherit_nosymlinks)
902 di_flags |= XFS_DIFLAG_NOSYMLINKS;
903 if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
904 xfs_inherit_nodefrag)
905 di_flags |= XFS_DIFLAG_NODEFRAG;
906 if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
907 di_flags |= XFS_DIFLAG_FILESTREAM;
908
909 ip->i_d.di_flags |= di_flags;
910 }
911 if (pip &&
912 (pip->i_d.di_flags2 & XFS_DIFLAG2_ANY) &&
913 pip->i_d.di_version == 3 &&
914 ip->i_d.di_version == 3) {
915 uint64_t di_flags2 = 0;
916
917 if (pip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) {
918 di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
919 ip->i_d.di_cowextsize = pip->i_d.di_cowextsize;
920 }
921 if (pip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
922 di_flags2 |= XFS_DIFLAG2_DAX;
923
924 ip->i_d.di_flags2 |= di_flags2;
925 }
926
927 case S_IFLNK:
928 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
929 ip->i_df.if_flags = XFS_IFEXTENTS;
930 ip->i_df.if_bytes = ip->i_df.if_real_bytes = 0;
931 ip->i_df.if_u1.if_root = NULL;
932 break;
933 default:
934 ASSERT(0);
935 }
936
937
938
939 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
940 ip->i_d.di_anextents = 0;
941
942
943
944
945 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
946 xfs_trans_log_inode(tp, ip, flags);
947
948
949 xfs_setup_inode(ip);
950
951 *ipp = ip;
952 return 0;
953}
954
955
956
957
958
959
960
961
962
963
964
965int
966xfs_dir_ialloc(
967 xfs_trans_t **tpp,
968
969 xfs_inode_t *dp,
970
971 umode_t mode,
972 xfs_nlink_t nlink,
973 dev_t rdev,
974 prid_t prid,
975 xfs_inode_t **ipp)
976
977{
978 xfs_trans_t *tp;
979 xfs_inode_t *ip;
980 xfs_buf_t *ialloc_context = NULL;
981 int code;
982 void *dqinfo;
983 uint tflags;
984
985 tp = *tpp;
986 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003 code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid, &ialloc_context,
1004 &ip);
1005
1006
1007
1008
1009
1010
1011 if (code) {
1012 *ipp = NULL;
1013 return code;
1014 }
1015 if (!ialloc_context && !ip) {
1016 *ipp = NULL;
1017 return -ENOSPC;
1018 }
1019
1020
1021
1022
1023
1024
1025
1026 if (ialloc_context) {
1027
1028
1029
1030
1031
1032
1033
1034 xfs_trans_bhold(tp, ialloc_context);
1035
1036
1037
1038
1039
1040
1041 dqinfo = NULL;
1042 tflags = 0;
1043 if (tp->t_dqinfo) {
1044 dqinfo = (void *)tp->t_dqinfo;
1045 tp->t_dqinfo = NULL;
1046 tflags = tp->t_flags & XFS_TRANS_DQ_DIRTY;
1047 tp->t_flags &= ~(XFS_TRANS_DQ_DIRTY);
1048 }
1049
1050 code = xfs_trans_roll(&tp);
1051
1052
1053
1054
1055 if (dqinfo) {
1056 tp->t_dqinfo = dqinfo;
1057 tp->t_flags |= tflags;
1058 }
1059
1060 if (code) {
1061 xfs_buf_relse(ialloc_context);
1062 *tpp = tp;
1063 *ipp = NULL;
1064 return code;
1065 }
1066 xfs_trans_bjoin(tp, ialloc_context);
1067
1068
1069
1070
1071
1072
1073 code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid,
1074 &ialloc_context, &ip);
1075
1076
1077
1078
1079
1080 if (code) {
1081 *tpp = tp;
1082 *ipp = NULL;
1083 return code;
1084 }
1085 ASSERT(!ialloc_context && ip);
1086
1087 }
1088
1089 *ipp = ip;
1090 *tpp = tp;
1091
1092 return 0;
1093}
1094
1095
1096
1097
1098
1099
1100static int
1101xfs_droplink(
1102 xfs_trans_t *tp,
1103 xfs_inode_t *ip)
1104{
1105 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1106
1107 drop_nlink(VFS_I(ip));
1108 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1109
1110 if (VFS_I(ip)->i_nlink)
1111 return 0;
1112
1113 return xfs_iunlink(tp, ip);
1114}
1115
1116
1117
1118
1119static int
1120xfs_bumplink(
1121 xfs_trans_t *tp,
1122 xfs_inode_t *ip)
1123{
1124 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1125
1126 ASSERT(ip->i_d.di_version > 1);
1127 inc_nlink(VFS_I(ip));
1128 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1129 return 0;
1130}
1131
1132int
1133xfs_create(
1134 xfs_inode_t *dp,
1135 struct xfs_name *name,
1136 umode_t mode,
1137 dev_t rdev,
1138 xfs_inode_t **ipp)
1139{
1140 int is_dir = S_ISDIR(mode);
1141 struct xfs_mount *mp = dp->i_mount;
1142 struct xfs_inode *ip = NULL;
1143 struct xfs_trans *tp = NULL;
1144 int error;
1145 struct xfs_defer_ops dfops;
1146 xfs_fsblock_t first_block;
1147 bool unlock_dp_on_error = false;
1148 prid_t prid;
1149 struct xfs_dquot *udqp = NULL;
1150 struct xfs_dquot *gdqp = NULL;
1151 struct xfs_dquot *pdqp = NULL;
1152 struct xfs_trans_res *tres;
1153 uint resblks;
1154
1155 trace_xfs_create(dp, name);
1156
1157 if (XFS_FORCED_SHUTDOWN(mp))
1158 return -EIO;
1159
1160 prid = xfs_get_initial_prid(dp);
1161
1162
1163
1164
1165 error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1166 xfs_kgid_to_gid(current_fsgid()), prid,
1167 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1168 &udqp, &gdqp, &pdqp);
1169 if (error)
1170 return error;
1171
1172 if (is_dir) {
1173 resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
1174 tres = &M_RES(mp)->tr_mkdir;
1175 } else {
1176 resblks = XFS_CREATE_SPACE_RES(mp, name->len);
1177 tres = &M_RES(mp)->tr_create;
1178 }
1179
1180
1181
1182
1183
1184
1185
1186 error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
1187 if (error == -ENOSPC) {
1188
1189 xfs_flush_inodes(mp);
1190 error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
1191 }
1192 if (error)
1193 goto out_release_inode;
1194
1195 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1196 unlock_dp_on_error = true;
1197
1198 xfs_defer_init(&dfops, &first_block);
1199
1200
1201
1202
1203 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1204 pdqp, resblks, 1, 0);
1205 if (error)
1206 goto out_trans_cancel;
1207
1208
1209
1210
1211
1212
1213 error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev, prid, &ip);
1214 if (error)
1215 goto out_trans_cancel;
1216
1217
1218
1219
1220
1221
1222
1223
1224 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1225 unlock_dp_on_error = false;
1226
1227 error = xfs_dir_createname(tp, dp, name, ip->i_ino,
1228 &first_block, &dfops, resblks ?
1229 resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
1230 if (error) {
1231 ASSERT(error != -ENOSPC);
1232 goto out_trans_cancel;
1233 }
1234 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1235 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1236
1237 if (is_dir) {
1238 error = xfs_dir_init(tp, ip, dp);
1239 if (error)
1240 goto out_bmap_cancel;
1241
1242 error = xfs_bumplink(tp, dp);
1243 if (error)
1244 goto out_bmap_cancel;
1245 }
1246
1247
1248
1249
1250
1251
1252 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1253 xfs_trans_set_sync(tp);
1254
1255
1256
1257
1258
1259
1260 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1261
1262 error = xfs_defer_finish(&tp, &dfops);
1263 if (error)
1264 goto out_bmap_cancel;
1265
1266 error = xfs_trans_commit(tp);
1267 if (error)
1268 goto out_release_inode;
1269
1270 xfs_qm_dqrele(udqp);
1271 xfs_qm_dqrele(gdqp);
1272 xfs_qm_dqrele(pdqp);
1273
1274 *ipp = ip;
1275 return 0;
1276
1277 out_bmap_cancel:
1278 xfs_defer_cancel(&dfops);
1279 out_trans_cancel:
1280 xfs_trans_cancel(tp);
1281 out_release_inode:
1282
1283
1284
1285
1286
1287 if (ip) {
1288 xfs_finish_inode_setup(ip);
1289 IRELE(ip);
1290 }
1291
1292 xfs_qm_dqrele(udqp);
1293 xfs_qm_dqrele(gdqp);
1294 xfs_qm_dqrele(pdqp);
1295
1296 if (unlock_dp_on_error)
1297 xfs_iunlock(dp, XFS_ILOCK_EXCL);
1298 return error;
1299}
1300
1301int
1302xfs_create_tmpfile(
1303 struct xfs_inode *dp,
1304 umode_t mode,
1305 struct xfs_inode **ipp)
1306{
1307 struct xfs_mount *mp = dp->i_mount;
1308 struct xfs_inode *ip = NULL;
1309 struct xfs_trans *tp = NULL;
1310 int error;
1311 prid_t prid;
1312 struct xfs_dquot *udqp = NULL;
1313 struct xfs_dquot *gdqp = NULL;
1314 struct xfs_dquot *pdqp = NULL;
1315 struct xfs_trans_res *tres;
1316 uint resblks;
1317
1318 if (XFS_FORCED_SHUTDOWN(mp))
1319 return -EIO;
1320
1321 prid = xfs_get_initial_prid(dp);
1322
1323
1324
1325
1326 error = xfs_qm_vop_dqalloc(dp, xfs_kuid_to_uid(current_fsuid()),
1327 xfs_kgid_to_gid(current_fsgid()), prid,
1328 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
1329 &udqp, &gdqp, &pdqp);
1330 if (error)
1331 return error;
1332
1333 resblks = XFS_IALLOC_SPACE_RES(mp);
1334 tres = &M_RES(mp)->tr_create_tmpfile;
1335
1336 error = xfs_trans_alloc(mp, tres, resblks, 0, 0, &tp);
1337 if (error)
1338 goto out_release_inode;
1339
1340 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
1341 pdqp, resblks, 1, 0);
1342 if (error)
1343 goto out_trans_cancel;
1344
1345 error = xfs_dir_ialloc(&tp, dp, mode, 1, 0, prid, &ip);
1346 if (error)
1347 goto out_trans_cancel;
1348
1349 if (mp->m_flags & XFS_MOUNT_WSYNC)
1350 xfs_trans_set_sync(tp);
1351
1352
1353
1354
1355
1356
1357 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
1358
1359 error = xfs_iunlink(tp, ip);
1360 if (error)
1361 goto out_trans_cancel;
1362
1363 error = xfs_trans_commit(tp);
1364 if (error)
1365 goto out_release_inode;
1366
1367 xfs_qm_dqrele(udqp);
1368 xfs_qm_dqrele(gdqp);
1369 xfs_qm_dqrele(pdqp);
1370
1371 *ipp = ip;
1372 return 0;
1373
1374 out_trans_cancel:
1375 xfs_trans_cancel(tp);
1376 out_release_inode:
1377
1378
1379
1380
1381
1382 if (ip) {
1383 xfs_finish_inode_setup(ip);
1384 IRELE(ip);
1385 }
1386
1387 xfs_qm_dqrele(udqp);
1388 xfs_qm_dqrele(gdqp);
1389 xfs_qm_dqrele(pdqp);
1390
1391 return error;
1392}
1393
1394int
1395xfs_link(
1396 xfs_inode_t *tdp,
1397 xfs_inode_t *sip,
1398 struct xfs_name *target_name)
1399{
1400 xfs_mount_t *mp = tdp->i_mount;
1401 xfs_trans_t *tp;
1402 int error;
1403 struct xfs_defer_ops dfops;
1404 xfs_fsblock_t first_block;
1405 int resblks;
1406
1407 trace_xfs_link(tdp, target_name);
1408
1409 ASSERT(!S_ISDIR(VFS_I(sip)->i_mode));
1410
1411 if (XFS_FORCED_SHUTDOWN(mp))
1412 return -EIO;
1413
1414 error = xfs_qm_dqattach(sip, 0);
1415 if (error)
1416 goto std_return;
1417
1418 error = xfs_qm_dqattach(tdp, 0);
1419 if (error)
1420 goto std_return;
1421
1422 resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
1423 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, resblks, 0, 0, &tp);
1424 if (error == -ENOSPC) {
1425 resblks = 0;
1426 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_link, 0, 0, 0, &tp);
1427 }
1428 if (error)
1429 goto std_return;
1430
1431 xfs_lock_two_inodes(sip, XFS_ILOCK_EXCL, tdp, XFS_ILOCK_EXCL);
1432
1433 xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
1434 xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
1435
1436
1437
1438
1439
1440
1441 if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1442 (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
1443 error = -EXDEV;
1444 goto error_return;
1445 }
1446
1447 if (!resblks) {
1448 error = xfs_dir_canenter(tp, tdp, target_name);
1449 if (error)
1450 goto error_return;
1451 }
1452
1453 xfs_defer_init(&dfops, &first_block);
1454
1455
1456
1457
1458 if (VFS_I(sip)->i_nlink == 0) {
1459 error = xfs_iunlink_remove(tp, sip);
1460 if (error)
1461 goto error_return;
1462 }
1463
1464 error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
1465 &first_block, &dfops, resblks);
1466 if (error)
1467 goto error_return;
1468 xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1469 xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1470
1471 error = xfs_bumplink(tp, sip);
1472 if (error)
1473 goto error_return;
1474
1475
1476
1477
1478
1479
1480 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1481 xfs_trans_set_sync(tp);
1482
1483 error = xfs_defer_finish(&tp, &dfops);
1484 if (error) {
1485 xfs_defer_cancel(&dfops);
1486 goto error_return;
1487 }
1488
1489 return xfs_trans_commit(tp);
1490
1491 error_return:
1492 xfs_trans_cancel(tp);
1493 std_return:
1494 return error;
1495}
1496
1497
1498static void
1499xfs_itruncate_clear_reflink_flags(
1500 struct xfs_inode *ip)
1501{
1502 struct xfs_ifork *dfork;
1503 struct xfs_ifork *cfork;
1504
1505 if (!xfs_is_reflink_inode(ip))
1506 return;
1507 dfork = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1508 cfork = XFS_IFORK_PTR(ip, XFS_COW_FORK);
1509 if (dfork->if_bytes == 0 && cfork->if_bytes == 0)
1510 ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1511 if (cfork->if_bytes == 0)
1512 xfs_inode_clear_cowblocks_tag(ip);
1513}
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536int
1537xfs_itruncate_extents(
1538 struct xfs_trans **tpp,
1539 struct xfs_inode *ip,
1540 int whichfork,
1541 xfs_fsize_t new_size)
1542{
1543 struct xfs_mount *mp = ip->i_mount;
1544 struct xfs_trans *tp = *tpp;
1545 struct xfs_defer_ops dfops;
1546 xfs_fsblock_t first_block;
1547 xfs_fileoff_t first_unmap_block;
1548 xfs_fileoff_t last_block;
1549 xfs_filblks_t unmap_len;
1550 int error = 0;
1551 int done = 0;
1552
1553 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1554 ASSERT(!atomic_read(&VFS_I(ip)->i_count) ||
1555 xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1556 ASSERT(new_size <= XFS_ISIZE(ip));
1557 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1558 ASSERT(ip->i_itemp != NULL);
1559 ASSERT(ip->i_itemp->ili_lock_flags == 0);
1560 ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1561
1562 trace_xfs_itruncate_extents_start(ip, new_size);
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573 first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1574 last_block = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
1575 if (first_unmap_block == last_block)
1576 return 0;
1577
1578 ASSERT(first_unmap_block < last_block);
1579 unmap_len = last_block - first_unmap_block + 1;
1580 while (!done) {
1581 xfs_defer_init(&dfops, &first_block);
1582 error = xfs_bunmapi(tp, ip,
1583 first_unmap_block, unmap_len,
1584 xfs_bmapi_aflag(whichfork),
1585 XFS_ITRUNC_MAX_EXTENTS,
1586 &first_block, &dfops,
1587 &done);
1588 if (error)
1589 goto out_bmap_cancel;
1590
1591
1592
1593
1594
1595 xfs_defer_ijoin(&dfops, ip);
1596 error = xfs_defer_finish(&tp, &dfops);
1597 if (error)
1598 goto out_bmap_cancel;
1599
1600 error = xfs_trans_roll_inode(&tp, ip);
1601 if (error)
1602 goto out;
1603 }
1604
1605 if (whichfork == XFS_DATA_FORK) {
1606
1607 error = xfs_reflink_cancel_cow_blocks(ip, &tp,
1608 first_unmap_block, last_block, true);
1609 if (error)
1610 goto out;
1611
1612 xfs_itruncate_clear_reflink_flags(ip);
1613 }
1614
1615
1616
1617
1618
1619 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1620
1621 trace_xfs_itruncate_extents_end(ip, new_size);
1622
1623out:
1624 *tpp = tp;
1625 return error;
1626out_bmap_cancel:
1627
1628
1629
1630
1631
1632 xfs_defer_cancel(&dfops);
1633 goto out;
1634}
1635
1636int
1637xfs_release(
1638 xfs_inode_t *ip)
1639{
1640 xfs_mount_t *mp = ip->i_mount;
1641 int error;
1642
1643 if (!S_ISREG(VFS_I(ip)->i_mode) || (VFS_I(ip)->i_mode == 0))
1644 return 0;
1645
1646
1647 if (mp->m_flags & XFS_MOUNT_RDONLY)
1648 return 0;
1649
1650 if (!XFS_FORCED_SHUTDOWN(mp)) {
1651 int truncated;
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
1664 if (truncated) {
1665 xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
1666 if (ip->i_delayed_blks > 0) {
1667 error = filemap_flush(VFS_I(ip)->i_mapping);
1668 if (error)
1669 return error;
1670 }
1671 }
1672 }
1673
1674 if (VFS_I(ip)->i_nlink == 0)
1675 return 0;
1676
1677 if (xfs_can_free_eofblocks(ip, false)) {
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693 if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
1694 return 0;
1695
1696
1697
1698
1699
1700
1701
1702 if (xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
1703 error = xfs_free_eofblocks(ip);
1704 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1705 if (error)
1706 return error;
1707 }
1708
1709
1710 if (ip->i_delayed_blks)
1711 xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
1712 }
1713 return 0;
1714}
1715
1716
1717
1718
1719
1720
1721STATIC int
1722xfs_inactive_truncate(
1723 struct xfs_inode *ip)
1724{
1725 struct xfs_mount *mp = ip->i_mount;
1726 struct xfs_trans *tp;
1727 int error;
1728
1729 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
1730 if (error) {
1731 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1732 return error;
1733 }
1734
1735 xfs_ilock(ip, XFS_ILOCK_EXCL);
1736 xfs_trans_ijoin(tp, ip, 0);
1737
1738
1739
1740
1741
1742
1743 ip->i_d.di_size = 0;
1744 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1745
1746 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
1747 if (error)
1748 goto error_trans_cancel;
1749
1750 ASSERT(ip->i_d.di_nextents == 0);
1751
1752 error = xfs_trans_commit(tp);
1753 if (error)
1754 goto error_unlock;
1755
1756 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1757 return 0;
1758
1759error_trans_cancel:
1760 xfs_trans_cancel(tp);
1761error_unlock:
1762 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1763 return error;
1764}
1765
1766
1767
1768
1769
1770
1771STATIC int
1772xfs_inactive_ifree(
1773 struct xfs_inode *ip)
1774{
1775 struct xfs_defer_ops dfops;
1776 xfs_fsblock_t first_block;
1777 struct xfs_mount *mp = ip->i_mount;
1778 struct xfs_trans *tp;
1779 int error;
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792 if (unlikely(mp->m_inotbt_nores)) {
1793 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree,
1794 XFS_IFREE_SPACE_RES(mp), 0, XFS_TRANS_RESERVE,
1795 &tp);
1796 } else {
1797 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ifree, 0, 0, 0, &tp);
1798 }
1799 if (error) {
1800 if (error == -ENOSPC) {
1801 xfs_warn_ratelimited(mp,
1802 "Failed to remove inode(s) from unlinked list. "
1803 "Please free space, unmount and run xfs_repair.");
1804 } else {
1805 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1806 }
1807 return error;
1808 }
1809
1810 xfs_ilock(ip, XFS_ILOCK_EXCL);
1811 xfs_trans_ijoin(tp, ip, 0);
1812
1813 xfs_defer_init(&dfops, &first_block);
1814 error = xfs_ifree(tp, ip, &dfops);
1815 if (error) {
1816
1817
1818
1819
1820
1821 if (!XFS_FORCED_SHUTDOWN(mp)) {
1822 xfs_notice(mp, "%s: xfs_ifree returned error %d",
1823 __func__, error);
1824 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1825 }
1826 xfs_trans_cancel(tp);
1827 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1828 return error;
1829 }
1830
1831
1832
1833
1834 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1835
1836
1837
1838
1839
1840 error = xfs_defer_finish(&tp, &dfops);
1841 if (error) {
1842 xfs_notice(mp, "%s: xfs_defer_finish returned error %d",
1843 __func__, error);
1844 xfs_defer_cancel(&dfops);
1845 }
1846 error = xfs_trans_commit(tp);
1847 if (error)
1848 xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
1849 __func__, error);
1850
1851 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1852 return 0;
1853}
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863void
1864xfs_inactive(
1865 xfs_inode_t *ip)
1866{
1867 struct xfs_mount *mp;
1868 struct xfs_ifork *cow_ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
1869 int error;
1870 int truncate = 0;
1871
1872
1873
1874
1875
1876 if (VFS_I(ip)->i_mode == 0) {
1877 ASSERT(ip->i_df.if_real_bytes == 0);
1878 ASSERT(ip->i_df.if_broot_bytes == 0);
1879 return;
1880 }
1881
1882 mp = ip->i_mount;
1883 ASSERT(!xfs_iflags_test(ip, XFS_IRECOVERY));
1884
1885
1886 if (mp->m_flags & XFS_MOUNT_RDONLY)
1887 return;
1888
1889
1890 if (xfs_is_reflink_inode(ip) && cow_ifp->if_bytes > 0)
1891 xfs_reflink_cancel_cow_range(ip, 0, NULLFILEOFF, true);
1892
1893 if (VFS_I(ip)->i_nlink != 0) {
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903 if (xfs_can_free_eofblocks(ip, true))
1904 xfs_free_eofblocks(ip);
1905
1906 return;
1907 }
1908
1909 if (S_ISREG(VFS_I(ip)->i_mode) &&
1910 (ip->i_d.di_size != 0 || XFS_ISIZE(ip) != 0 ||
1911 ip->i_d.di_nextents > 0 || ip->i_delayed_blks > 0))
1912 truncate = 1;
1913
1914 error = xfs_qm_dqattach(ip, 0);
1915 if (error)
1916 return;
1917
1918 if (S_ISLNK(VFS_I(ip)->i_mode))
1919 error = xfs_inactive_symlink(ip);
1920 else if (truncate)
1921 error = xfs_inactive_truncate(ip);
1922 if (error)
1923 return;
1924
1925
1926
1927
1928
1929
1930 if (XFS_IFORK_Q(ip)) {
1931 error = xfs_attr_inactive(ip);
1932 if (error)
1933 return;
1934 }
1935
1936 ASSERT(!ip->i_afp);
1937 ASSERT(ip->i_d.di_anextents == 0);
1938 ASSERT(ip->i_d.di_forkoff == 0);
1939
1940
1941
1942
1943 error = xfs_inactive_ifree(ip);
1944 if (error)
1945 return;
1946
1947
1948
1949
1950 xfs_qm_dqdetach(ip);
1951}
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963STATIC int
1964xfs_iunlink(
1965 struct xfs_trans *tp,
1966 struct xfs_inode *ip)
1967{
1968 xfs_mount_t *mp = tp->t_mountp;
1969 xfs_agi_t *agi;
1970 xfs_dinode_t *dip;
1971 xfs_buf_t *agibp;
1972 xfs_buf_t *ibp;
1973 xfs_agino_t agino;
1974 short bucket_index;
1975 int offset;
1976 int error;
1977
1978 ASSERT(VFS_I(ip)->i_mode != 0);
1979
1980
1981
1982
1983
1984 error = xfs_read_agi(mp, tp, XFS_INO_TO_AGNO(mp, ip->i_ino), &agibp);
1985 if (error)
1986 return error;
1987 agi = XFS_BUF_TO_AGI(agibp);
1988
1989
1990
1991
1992
1993 agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
1994 ASSERT(agino != 0);
1995 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
1996 ASSERT(agi->agi_unlinked[bucket_index]);
1997 ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino);
1998
1999 if (agi->agi_unlinked[bucket_index] != cpu_to_be32(NULLAGINO)) {
2000
2001
2002
2003
2004
2005
2006 error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2007 0, 0);
2008 if (error)
2009 return error;
2010
2011 ASSERT(dip->di_next_unlinked == cpu_to_be32(NULLAGINO));
2012 dip->di_next_unlinked = agi->agi_unlinked[bucket_index];
2013 offset = ip->i_imap.im_boffset +
2014 offsetof(xfs_dinode_t, di_next_unlinked);
2015
2016
2017 xfs_dinode_calc_crc(mp, dip);
2018
2019 xfs_trans_inode_buf(tp, ibp);
2020 xfs_trans_log_buf(tp, ibp, offset,
2021 (offset + sizeof(xfs_agino_t) - 1));
2022 xfs_inobp_check(mp, ibp);
2023 }
2024
2025
2026
2027
2028 ASSERT(agino != 0);
2029 agi->agi_unlinked[bucket_index] = cpu_to_be32(agino);
2030 offset = offsetof(xfs_agi_t, agi_unlinked) +
2031 (sizeof(xfs_agino_t) * bucket_index);
2032 xfs_trans_log_buf(tp, agibp, offset,
2033 (offset + sizeof(xfs_agino_t) - 1));
2034 return 0;
2035}
2036
2037
2038
2039
2040STATIC int
2041xfs_iunlink_remove(
2042 xfs_trans_t *tp,
2043 xfs_inode_t *ip)
2044{
2045 xfs_ino_t next_ino;
2046 xfs_mount_t *mp;
2047 xfs_agi_t *agi;
2048 xfs_dinode_t *dip;
2049 xfs_buf_t *agibp;
2050 xfs_buf_t *ibp;
2051 xfs_agnumber_t agno;
2052 xfs_agino_t agino;
2053 xfs_agino_t next_agino;
2054 xfs_buf_t *last_ibp;
2055 xfs_dinode_t *last_dip = NULL;
2056 short bucket_index;
2057 int offset, last_offset = 0;
2058 int error;
2059
2060 mp = tp->t_mountp;
2061 agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
2062
2063
2064
2065
2066
2067 error = xfs_read_agi(mp, tp, agno, &agibp);
2068 if (error)
2069 return error;
2070
2071 agi = XFS_BUF_TO_AGI(agibp);
2072
2073
2074
2075
2076
2077 agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2078 ASSERT(agino != 0);
2079 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2080 ASSERT(agi->agi_unlinked[bucket_index] != cpu_to_be32(NULLAGINO));
2081 ASSERT(agi->agi_unlinked[bucket_index]);
2082
2083 if (be32_to_cpu(agi->agi_unlinked[bucket_index]) == agino) {
2084
2085
2086
2087
2088
2089
2090
2091 error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2092 0, 0);
2093 if (error) {
2094 xfs_warn(mp, "%s: xfs_imap_to_bp returned error %d.",
2095 __func__, error);
2096 return error;
2097 }
2098 next_agino = be32_to_cpu(dip->di_next_unlinked);
2099 ASSERT(next_agino != 0);
2100 if (next_agino != NULLAGINO) {
2101 dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
2102 offset = ip->i_imap.im_boffset +
2103 offsetof(xfs_dinode_t, di_next_unlinked);
2104
2105
2106 xfs_dinode_calc_crc(mp, dip);
2107
2108 xfs_trans_inode_buf(tp, ibp);
2109 xfs_trans_log_buf(tp, ibp, offset,
2110 (offset + sizeof(xfs_agino_t) - 1));
2111 xfs_inobp_check(mp, ibp);
2112 } else {
2113 xfs_trans_brelse(tp, ibp);
2114 }
2115
2116
2117
2118 ASSERT(next_agino != 0);
2119 ASSERT(next_agino != agino);
2120 agi->agi_unlinked[bucket_index] = cpu_to_be32(next_agino);
2121 offset = offsetof(xfs_agi_t, agi_unlinked) +
2122 (sizeof(xfs_agino_t) * bucket_index);
2123 xfs_trans_log_buf(tp, agibp, offset,
2124 (offset + sizeof(xfs_agino_t) - 1));
2125 } else {
2126
2127
2128
2129 next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2130 last_ibp = NULL;
2131 while (next_agino != agino) {
2132 struct xfs_imap imap;
2133
2134 if (last_ibp)
2135 xfs_trans_brelse(tp, last_ibp);
2136
2137 imap.im_blkno = 0;
2138 next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino);
2139
2140 error = xfs_imap(mp, tp, next_ino, &imap, 0);
2141 if (error) {
2142 xfs_warn(mp,
2143 "%s: xfs_imap returned error %d.",
2144 __func__, error);
2145 return error;
2146 }
2147
2148 error = xfs_imap_to_bp(mp, tp, &imap, &last_dip,
2149 &last_ibp, 0, 0);
2150 if (error) {
2151 xfs_warn(mp,
2152 "%s: xfs_imap_to_bp returned error %d.",
2153 __func__, error);
2154 return error;
2155 }
2156
2157 last_offset = imap.im_boffset;
2158 next_agino = be32_to_cpu(last_dip->di_next_unlinked);
2159 ASSERT(next_agino != NULLAGINO);
2160 ASSERT(next_agino != 0);
2161 }
2162
2163
2164
2165
2166
2167 error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &ibp,
2168 0, 0);
2169 if (error) {
2170 xfs_warn(mp, "%s: xfs_imap_to_bp(2) returned error %d.",
2171 __func__, error);
2172 return error;
2173 }
2174 next_agino = be32_to_cpu(dip->di_next_unlinked);
2175 ASSERT(next_agino != 0);
2176 ASSERT(next_agino != agino);
2177 if (next_agino != NULLAGINO) {
2178 dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
2179 offset = ip->i_imap.im_boffset +
2180 offsetof(xfs_dinode_t, di_next_unlinked);
2181
2182
2183 xfs_dinode_calc_crc(mp, dip);
2184
2185 xfs_trans_inode_buf(tp, ibp);
2186 xfs_trans_log_buf(tp, ibp, offset,
2187 (offset + sizeof(xfs_agino_t) - 1));
2188 xfs_inobp_check(mp, ibp);
2189 } else {
2190 xfs_trans_brelse(tp, ibp);
2191 }
2192
2193
2194
2195 last_dip->di_next_unlinked = cpu_to_be32(next_agino);
2196 ASSERT(next_agino != 0);
2197 offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked);
2198
2199
2200 xfs_dinode_calc_crc(mp, last_dip);
2201
2202 xfs_trans_inode_buf(tp, last_ibp);
2203 xfs_trans_log_buf(tp, last_ibp, offset,
2204 (offset + sizeof(xfs_agino_t) - 1));
2205 xfs_inobp_check(mp, last_ibp);
2206 }
2207 return 0;
2208}
2209
2210
2211
2212
2213
2214
2215STATIC int
2216xfs_ifree_cluster(
2217 xfs_inode_t *free_ip,
2218 xfs_trans_t *tp,
2219 struct xfs_icluster *xic)
2220{
2221 xfs_mount_t *mp = free_ip->i_mount;
2222 int blks_per_cluster;
2223 int inodes_per_cluster;
2224 int nbufs;
2225 int i, j;
2226 int ioffset;
2227 xfs_daddr_t blkno;
2228 xfs_buf_t *bp;
2229 xfs_inode_t *ip;
2230 xfs_inode_log_item_t *iip;
2231 struct xfs_log_item *lip;
2232 struct xfs_perag *pag;
2233 xfs_ino_t inum;
2234
2235 inum = xic->first_ino;
2236 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
2237 blks_per_cluster = xfs_icluster_size_fsb(mp);
2238 inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog;
2239 nbufs = mp->m_ialloc_blks / blks_per_cluster;
2240
2241 for (j = 0; j < nbufs; j++, inum += inodes_per_cluster) {
2242
2243
2244
2245
2246
2247 ioffset = inum - xic->first_ino;
2248 if ((xic->alloc & XFS_INOBT_MASK(ioffset)) == 0) {
2249 ASSERT(do_mod(ioffset, inodes_per_cluster) == 0);
2250 continue;
2251 }
2252
2253 blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
2254 XFS_INO_TO_AGBNO(mp, inum));
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
2265 mp->m_bsize * blks_per_cluster,
2266 XBF_UNMAPPED);
2267
2268 if (!bp)
2269 return -ENOMEM;
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280 bp->b_ops = &xfs_inode_buf_ops;
2281
2282
2283
2284
2285
2286
2287
2288
2289 list_for_each_entry(lip, &bp->b_li_list, li_bio_list) {
2290 if (lip->li_type == XFS_LI_INODE) {
2291 iip = (xfs_inode_log_item_t *)lip;
2292 ASSERT(iip->ili_logged == 1);
2293 lip->li_cb = xfs_istale_done;
2294 xfs_trans_ail_copy_lsn(mp->m_ail,
2295 &iip->ili_flush_lsn,
2296 &iip->ili_item.li_lsn);
2297 xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
2298 }
2299 }
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312 for (i = 0; i < inodes_per_cluster; i++) {
2313retry:
2314 rcu_read_lock();
2315 ip = radix_tree_lookup(&pag->pag_ici_root,
2316 XFS_INO_TO_AGINO(mp, (inum + i)));
2317
2318
2319 if (!ip) {
2320 rcu_read_unlock();
2321 continue;
2322 }
2323
2324
2325
2326
2327
2328
2329
2330
2331 spin_lock(&ip->i_flags_lock);
2332 if (ip->i_ino != inum + i ||
2333 __xfs_iflags_test(ip, XFS_ISTALE)) {
2334 spin_unlock(&ip->i_flags_lock);
2335 rcu_read_unlock();
2336 continue;
2337 }
2338 spin_unlock(&ip->i_flags_lock);
2339
2340
2341
2342
2343
2344
2345
2346
2347 if (ip != free_ip) {
2348 if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2349 rcu_read_unlock();
2350 delay(1);
2351 goto retry;
2352 }
2353
2354
2355
2356
2357
2358
2359
2360
2361 if (ip->i_ino != inum + i) {
2362 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2363 rcu_read_unlock();
2364 continue;
2365 }
2366 }
2367 rcu_read_unlock();
2368
2369 xfs_iflock(ip);
2370 xfs_iflags_set(ip, XFS_ISTALE);
2371
2372
2373
2374
2375
2376 iip = ip->i_itemp;
2377 if (!iip || xfs_inode_clean(ip)) {
2378 ASSERT(ip != free_ip);
2379 xfs_ifunlock(ip);
2380 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2381 continue;
2382 }
2383
2384 iip->ili_last_fields = iip->ili_fields;
2385 iip->ili_fields = 0;
2386 iip->ili_fsync_fields = 0;
2387 iip->ili_logged = 1;
2388 xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
2389 &iip->ili_item.li_lsn);
2390
2391 xfs_buf_attach_iodone(bp, xfs_istale_done,
2392 &iip->ili_item);
2393
2394 if (ip != free_ip)
2395 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2396 }
2397
2398 xfs_trans_stale_inode_buf(tp, bp);
2399 xfs_trans_binval(tp, bp);
2400 }
2401
2402 xfs_perag_put(pag);
2403 return 0;
2404}
2405
2406
2407
2408
2409
2410static inline void
2411xfs_ifree_local_data(
2412 struct xfs_inode *ip,
2413 int whichfork)
2414{
2415 struct xfs_ifork *ifp;
2416
2417 if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL)
2418 return;
2419
2420 ifp = XFS_IFORK_PTR(ip, whichfork);
2421 xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
2422}
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434int
2435xfs_ifree(
2436 xfs_trans_t *tp,
2437 xfs_inode_t *ip,
2438 struct xfs_defer_ops *dfops)
2439{
2440 int error;
2441 struct xfs_icluster xic = { 0 };
2442
2443 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2444 ASSERT(VFS_I(ip)->i_nlink == 0);
2445 ASSERT(ip->i_d.di_nextents == 0);
2446 ASSERT(ip->i_d.di_anextents == 0);
2447 ASSERT(ip->i_d.di_size == 0 || !S_ISREG(VFS_I(ip)->i_mode));
2448 ASSERT(ip->i_d.di_nblocks == 0);
2449
2450
2451
2452
2453 error = xfs_iunlink_remove(tp, ip);
2454 if (error)
2455 return error;
2456
2457 error = xfs_difree(tp, ip->i_ino, dfops, &xic);
2458 if (error)
2459 return error;
2460
2461 xfs_ifree_local_data(ip, XFS_DATA_FORK);
2462 xfs_ifree_local_data(ip, XFS_ATTR_FORK);
2463
2464 VFS_I(ip)->i_mode = 0;
2465 ip->i_d.di_flags = 0;
2466 ip->i_d.di_flags2 = 0;
2467 ip->i_d.di_dmevmask = 0;
2468 ip->i_d.di_forkoff = 0;
2469 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
2470 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
2471
2472
2473 ip->i_itemp->ili_fields &= ~(XFS_ILOG_AOWNER|XFS_ILOG_DOWNER);
2474
2475
2476
2477
2478
2479 VFS_I(ip)->i_generation++;
2480 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2481
2482 if (xic.deleted)
2483 error = xfs_ifree_cluster(ip, tp, &xic);
2484
2485 return error;
2486}
2487
2488
2489
2490
2491
2492
2493static void
2494xfs_iunpin(
2495 struct xfs_inode *ip)
2496{
2497 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
2498
2499 trace_xfs_inode_unpin_nowait(ip, _RET_IP_);
2500
2501
2502 xfs_log_force_lsn(ip->i_mount, ip->i_itemp->ili_last_lsn, 0, NULL);
2503
2504}
2505
2506static void
2507__xfs_iunpin_wait(
2508 struct xfs_inode *ip)
2509{
2510 wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_IPINNED_BIT);
2511 DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_IPINNED_BIT);
2512
2513 xfs_iunpin(ip);
2514
2515 do {
2516 prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
2517 if (xfs_ipincount(ip))
2518 io_schedule();
2519 } while (xfs_ipincount(ip));
2520 finish_wait(wq, &wait.wq_entry);
2521}
2522
2523void
2524xfs_iunpin_wait(
2525 struct xfs_inode *ip)
2526{
2527 if (xfs_ipincount(ip))
2528 __xfs_iunpin_wait(ip);
2529}
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558int
2559xfs_remove(
2560 xfs_inode_t *dp,
2561 struct xfs_name *name,
2562 xfs_inode_t *ip)
2563{
2564 xfs_mount_t *mp = dp->i_mount;
2565 xfs_trans_t *tp = NULL;
2566 int is_dir = S_ISDIR(VFS_I(ip)->i_mode);
2567 int error = 0;
2568 struct xfs_defer_ops dfops;
2569 xfs_fsblock_t first_block;
2570 uint resblks;
2571
2572 trace_xfs_remove(dp, name);
2573
2574 if (XFS_FORCED_SHUTDOWN(mp))
2575 return -EIO;
2576
2577 error = xfs_qm_dqattach(dp, 0);
2578 if (error)
2579 goto std_return;
2580
2581 error = xfs_qm_dqattach(ip, 0);
2582 if (error)
2583 goto std_return;
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594 resblks = XFS_REMOVE_SPACE_RES(mp);
2595 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, resblks, 0, 0, &tp);
2596 if (error == -ENOSPC) {
2597 resblks = 0;
2598 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_remove, 0, 0, 0,
2599 &tp);
2600 }
2601 if (error) {
2602 ASSERT(error != -ENOSPC);
2603 goto std_return;
2604 }
2605
2606 xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
2607
2608 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
2609 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2610
2611
2612
2613
2614 if (is_dir) {
2615 ASSERT(VFS_I(ip)->i_nlink >= 2);
2616 if (VFS_I(ip)->i_nlink != 2) {
2617 error = -ENOTEMPTY;
2618 goto out_trans_cancel;
2619 }
2620 if (!xfs_dir_isempty(ip)) {
2621 error = -ENOTEMPTY;
2622 goto out_trans_cancel;
2623 }
2624
2625
2626 error = xfs_droplink(tp, dp);
2627 if (error)
2628 goto out_trans_cancel;
2629
2630
2631 error = xfs_droplink(tp, ip);
2632 if (error)
2633 goto out_trans_cancel;
2634 } else {
2635
2636
2637
2638
2639
2640 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2641 }
2642 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2643
2644
2645 error = xfs_droplink(tp, ip);
2646 if (error)
2647 goto out_trans_cancel;
2648
2649 xfs_defer_init(&dfops, &first_block);
2650 error = xfs_dir_removename(tp, dp, name, ip->i_ino,
2651 &first_block, &dfops, resblks);
2652 if (error) {
2653 ASSERT(error != -ENOENT);
2654 goto out_bmap_cancel;
2655 }
2656
2657
2658
2659
2660
2661
2662 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
2663 xfs_trans_set_sync(tp);
2664
2665 error = xfs_defer_finish(&tp, &dfops);
2666 if (error)
2667 goto out_bmap_cancel;
2668
2669 error = xfs_trans_commit(tp);
2670 if (error)
2671 goto std_return;
2672
2673 if (is_dir && xfs_inode_is_filestream(ip))
2674 xfs_filestream_deassociate(ip);
2675
2676 return 0;
2677
2678 out_bmap_cancel:
2679 xfs_defer_cancel(&dfops);
2680 out_trans_cancel:
2681 xfs_trans_cancel(tp);
2682 std_return:
2683 return error;
2684}
2685
2686
2687
2688
2689#define __XFS_SORT_INODES 5
2690STATIC void
2691xfs_sort_for_rename(
2692 struct xfs_inode *dp1,
2693 struct xfs_inode *dp2,
2694 struct xfs_inode *ip1,
2695 struct xfs_inode *ip2,
2696 struct xfs_inode *wip,
2697 struct xfs_inode **i_tab,
2698 int *num_inodes)
2699{
2700 int i, j;
2701
2702 ASSERT(*num_inodes == __XFS_SORT_INODES);
2703 memset(i_tab, 0, *num_inodes * sizeof(struct xfs_inode *));
2704
2705
2706
2707
2708
2709
2710
2711
2712 i = 0;
2713 i_tab[i++] = dp1;
2714 i_tab[i++] = dp2;
2715 i_tab[i++] = ip1;
2716 if (ip2)
2717 i_tab[i++] = ip2;
2718 if (wip)
2719 i_tab[i++] = wip;
2720 *num_inodes = i;
2721
2722
2723
2724
2725
2726 for (i = 0; i < *num_inodes; i++) {
2727 for (j = 1; j < *num_inodes; j++) {
2728 if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
2729 struct xfs_inode *temp = i_tab[j];
2730 i_tab[j] = i_tab[j-1];
2731 i_tab[j-1] = temp;
2732 }
2733 }
2734 }
2735}
2736
2737static int
2738xfs_finish_rename(
2739 struct xfs_trans *tp,
2740 struct xfs_defer_ops *dfops)
2741{
2742 int error;
2743
2744
2745
2746
2747
2748 if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
2749 xfs_trans_set_sync(tp);
2750
2751 error = xfs_defer_finish(&tp, dfops);
2752 if (error) {
2753 xfs_defer_cancel(dfops);
2754 xfs_trans_cancel(tp);
2755 return error;
2756 }
2757
2758 return xfs_trans_commit(tp);
2759}
2760
2761
2762
2763
2764
2765
2766STATIC int
2767xfs_cross_rename(
2768 struct xfs_trans *tp,
2769 struct xfs_inode *dp1,
2770 struct xfs_name *name1,
2771 struct xfs_inode *ip1,
2772 struct xfs_inode *dp2,
2773 struct xfs_name *name2,
2774 struct xfs_inode *ip2,
2775 struct xfs_defer_ops *dfops,
2776 xfs_fsblock_t *first_block,
2777 int spaceres)
2778{
2779 int error = 0;
2780 int ip1_flags = 0;
2781 int ip2_flags = 0;
2782 int dp2_flags = 0;
2783
2784
2785 error = xfs_dir_replace(tp, dp1, name1,
2786 ip2->i_ino,
2787 first_block, dfops, spaceres);
2788 if (error)
2789 goto out_trans_abort;
2790
2791
2792 error = xfs_dir_replace(tp, dp2, name2,
2793 ip1->i_ino,
2794 first_block, dfops, spaceres);
2795 if (error)
2796 goto out_trans_abort;
2797
2798
2799
2800
2801
2802
2803 if (dp1 != dp2) {
2804 dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2805
2806 if (S_ISDIR(VFS_I(ip2)->i_mode)) {
2807 error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
2808 dp1->i_ino, first_block,
2809 dfops, spaceres);
2810 if (error)
2811 goto out_trans_abort;
2812
2813
2814 if (!S_ISDIR(VFS_I(ip1)->i_mode)) {
2815 error = xfs_droplink(tp, dp2);
2816 if (error)
2817 goto out_trans_abort;
2818 error = xfs_bumplink(tp, dp1);
2819 if (error)
2820 goto out_trans_abort;
2821 }
2822
2823
2824
2825
2826
2827
2828
2829 ip1_flags |= XFS_ICHGTIME_CHG;
2830 ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2831 }
2832
2833 if (S_ISDIR(VFS_I(ip1)->i_mode)) {
2834 error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
2835 dp2->i_ino, first_block,
2836 dfops, spaceres);
2837 if (error)
2838 goto out_trans_abort;
2839
2840
2841 if (!S_ISDIR(VFS_I(ip2)->i_mode)) {
2842 error = xfs_droplink(tp, dp1);
2843 if (error)
2844 goto out_trans_abort;
2845 error = xfs_bumplink(tp, dp2);
2846 if (error)
2847 goto out_trans_abort;
2848 }
2849
2850
2851
2852
2853
2854
2855
2856 ip1_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
2857 ip2_flags |= XFS_ICHGTIME_CHG;
2858 }
2859 }
2860
2861 if (ip1_flags) {
2862 xfs_trans_ichgtime(tp, ip1, ip1_flags);
2863 xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE);
2864 }
2865 if (ip2_flags) {
2866 xfs_trans_ichgtime(tp, ip2, ip2_flags);
2867 xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE);
2868 }
2869 if (dp2_flags) {
2870 xfs_trans_ichgtime(tp, dp2, dp2_flags);
2871 xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE);
2872 }
2873 xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2874 xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
2875 return xfs_finish_rename(tp, dfops);
2876
2877out_trans_abort:
2878 xfs_defer_cancel(dfops);
2879 xfs_trans_cancel(tp);
2880 return error;
2881}
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891static int
2892xfs_rename_alloc_whiteout(
2893 struct xfs_inode *dp,
2894 struct xfs_inode **wip)
2895{
2896 struct xfs_inode *tmpfile;
2897 int error;
2898
2899 error = xfs_create_tmpfile(dp, S_IFCHR | WHITEOUT_MODE, &tmpfile);
2900 if (error)
2901 return error;
2902
2903
2904
2905
2906
2907
2908
2909 drop_nlink(VFS_I(tmpfile));
2910 xfs_setup_iops(tmpfile);
2911 xfs_finish_inode_setup(tmpfile);
2912 VFS_I(tmpfile)->i_state |= I_LINKABLE;
2913
2914 *wip = tmpfile;
2915 return 0;
2916}
2917
2918
2919
2920
2921int
2922xfs_rename(
2923 struct xfs_inode *src_dp,
2924 struct xfs_name *src_name,
2925 struct xfs_inode *src_ip,
2926 struct xfs_inode *target_dp,
2927 struct xfs_name *target_name,
2928 struct xfs_inode *target_ip,
2929 unsigned int flags)
2930{
2931 struct xfs_mount *mp = src_dp->i_mount;
2932 struct xfs_trans *tp;
2933 struct xfs_defer_ops dfops;
2934 xfs_fsblock_t first_block;
2935 struct xfs_inode *wip = NULL;
2936 struct xfs_inode *inodes[__XFS_SORT_INODES];
2937 int num_inodes = __XFS_SORT_INODES;
2938 bool new_parent = (src_dp != target_dp);
2939 bool src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
2940 int spaceres;
2941 int error;
2942
2943 trace_xfs_rename(src_dp, target_dp, src_name, target_name);
2944
2945 if ((flags & RENAME_EXCHANGE) && !target_ip)
2946 return -EINVAL;
2947
2948
2949
2950
2951
2952
2953 if (flags & RENAME_WHITEOUT) {
2954 ASSERT(!(flags & (RENAME_NOREPLACE | RENAME_EXCHANGE)));
2955 error = xfs_rename_alloc_whiteout(target_dp, &wip);
2956 if (error)
2957 return error;
2958
2959
2960 src_name->type = XFS_DIR3_FT_CHRDEV;
2961 }
2962
2963 xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip, wip,
2964 inodes, &num_inodes);
2965
2966 spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
2967 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, spaceres, 0, 0, &tp);
2968 if (error == -ENOSPC) {
2969 spaceres = 0;
2970 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_rename, 0, 0, 0,
2971 &tp);
2972 }
2973 if (error)
2974 goto out_release_wip;
2975
2976
2977
2978
2979 error = xfs_qm_vop_rename_dqattach(inodes);
2980 if (error)
2981 goto out_trans_cancel;
2982
2983
2984
2985
2986
2987
2988
2989 xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
2990
2991
2992
2993
2994
2995
2996 xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
2997 if (new_parent)
2998 xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
2999 xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
3000 if (target_ip)
3001 xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
3002 if (wip)
3003 xfs_trans_ijoin(tp, wip, XFS_ILOCK_EXCL);
3004
3005
3006
3007
3008
3009
3010 if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
3011 (xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {
3012 error = -EXDEV;
3013 goto out_trans_cancel;
3014 }
3015
3016 xfs_defer_init(&dfops, &first_block);
3017
3018
3019 if (flags & RENAME_EXCHANGE)
3020 return xfs_cross_rename(tp, src_dp, src_name, src_ip,
3021 target_dp, target_name, target_ip,
3022 &dfops, &first_block, spaceres);
3023
3024
3025
3026
3027 if (target_ip == NULL) {
3028
3029
3030
3031
3032 if (!spaceres) {
3033 error = xfs_dir_canenter(tp, target_dp, target_name);
3034 if (error)
3035 goto out_trans_cancel;
3036 }
3037
3038
3039
3040
3041
3042 error = xfs_dir_createname(tp, target_dp, target_name,
3043 src_ip->i_ino, &first_block,
3044 &dfops, spaceres);
3045 if (error)
3046 goto out_bmap_cancel;
3047
3048 xfs_trans_ichgtime(tp, target_dp,
3049 XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3050
3051 if (new_parent && src_is_directory) {
3052 error = xfs_bumplink(tp, target_dp);
3053 if (error)
3054 goto out_bmap_cancel;
3055 }
3056 } else {
3057
3058
3059
3060
3061
3062 if (S_ISDIR(VFS_I(target_ip)->i_mode)) {
3063
3064
3065
3066 if (!(xfs_dir_isempty(target_ip)) ||
3067 (VFS_I(target_ip)->i_nlink > 2)) {
3068 error = -EEXIST;
3069 goto out_trans_cancel;
3070 }
3071 }
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082 error = xfs_dir_replace(tp, target_dp, target_name,
3083 src_ip->i_ino,
3084 &first_block, &dfops, spaceres);
3085 if (error)
3086 goto out_bmap_cancel;
3087
3088 xfs_trans_ichgtime(tp, target_dp,
3089 XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3090
3091
3092
3093
3094
3095 error = xfs_droplink(tp, target_ip);
3096 if (error)
3097 goto out_bmap_cancel;
3098
3099 if (src_is_directory) {
3100
3101
3102
3103 error = xfs_droplink(tp, target_ip);
3104 if (error)
3105 goto out_bmap_cancel;
3106 }
3107 }
3108
3109
3110
3111
3112 if (new_parent && src_is_directory) {
3113
3114
3115
3116
3117 error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
3118 target_dp->i_ino,
3119 &first_block, &dfops, spaceres);
3120 ASSERT(error != -EEXIST);
3121 if (error)
3122 goto out_bmap_cancel;
3123 }
3124
3125
3126
3127
3128
3129
3130
3131
3132 xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG);
3133 xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE);
3134
3135
3136
3137
3138
3139
3140 if (src_is_directory && (new_parent || target_ip != NULL)) {
3141
3142
3143
3144
3145
3146 error = xfs_droplink(tp, src_dp);
3147 if (error)
3148 goto out_bmap_cancel;
3149 }
3150
3151
3152
3153
3154
3155
3156 if (wip) {
3157 error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
3158 &first_block, &dfops, spaceres);
3159 } else
3160 error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
3161 &first_block, &dfops, spaceres);
3162 if (error)
3163 goto out_bmap_cancel;
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173 if (wip) {
3174 ASSERT(VFS_I(wip)->i_nlink == 0);
3175 error = xfs_bumplink(tp, wip);
3176 if (error)
3177 goto out_bmap_cancel;
3178 error = xfs_iunlink_remove(tp, wip);
3179 if (error)
3180 goto out_bmap_cancel;
3181 xfs_trans_log_inode(tp, wip, XFS_ILOG_CORE);
3182
3183
3184
3185
3186
3187
3188 VFS_I(wip)->i_state &= ~I_LINKABLE;
3189 }
3190
3191 xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3192 xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
3193 if (new_parent)
3194 xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
3195
3196 error = xfs_finish_rename(tp, &dfops);
3197 if (wip)
3198 IRELE(wip);
3199 return error;
3200
3201out_bmap_cancel:
3202 xfs_defer_cancel(&dfops);
3203out_trans_cancel:
3204 xfs_trans_cancel(tp);
3205out_release_wip:
3206 if (wip)
3207 IRELE(wip);
3208 return error;
3209}
3210
3211STATIC int
3212xfs_iflush_cluster(
3213 struct xfs_inode *ip,
3214 struct xfs_buf *bp)
3215{
3216 struct xfs_mount *mp = ip->i_mount;
3217 struct xfs_perag *pag;
3218 unsigned long first_index, mask;
3219 unsigned long inodes_per_cluster;
3220 int cilist_size;
3221 struct xfs_inode **cilist;
3222 struct xfs_inode *cip;
3223 int nr_found;
3224 int clcount = 0;
3225 int bufwasdelwri;
3226 int i;
3227
3228 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
3229
3230 inodes_per_cluster = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
3231 cilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
3232 cilist = kmem_alloc(cilist_size, KM_MAYFAIL|KM_NOFS);
3233 if (!cilist)
3234 goto out_put;
3235
3236 mask = ~(((mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog)) - 1);
3237 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
3238 rcu_read_lock();
3239
3240 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)cilist,
3241 first_index, inodes_per_cluster);
3242 if (nr_found == 0)
3243 goto out_free;
3244
3245 for (i = 0; i < nr_found; i++) {
3246 cip = cilist[i];
3247 if (cip == ip)
3248 continue;
3249
3250
3251
3252
3253
3254
3255
3256 spin_lock(&cip->i_flags_lock);
3257 if (!cip->i_ino ||
3258 __xfs_iflags_test(cip, XFS_ISTALE)) {
3259 spin_unlock(&cip->i_flags_lock);
3260 continue;
3261 }
3262
3263
3264
3265
3266
3267
3268 if ((XFS_INO_TO_AGINO(mp, cip->i_ino) & mask) != first_index) {
3269 spin_unlock(&cip->i_flags_lock);
3270 break;
3271 }
3272 spin_unlock(&cip->i_flags_lock);
3273
3274
3275
3276
3277
3278
3279 if (xfs_inode_clean(cip) && xfs_ipincount(cip) == 0)
3280 continue;
3281
3282
3283
3284
3285
3286
3287 if (!xfs_ilock_nowait(cip, XFS_ILOCK_SHARED))
3288 continue;
3289 if (!xfs_iflock_nowait(cip)) {
3290 xfs_iunlock(cip, XFS_ILOCK_SHARED);
3291 continue;
3292 }
3293 if (xfs_ipincount(cip)) {
3294 xfs_ifunlock(cip);
3295 xfs_iunlock(cip, XFS_ILOCK_SHARED);
3296 continue;
3297 }
3298
3299
3300
3301
3302
3303
3304
3305
3306 if (!cip->i_ino) {
3307 xfs_ifunlock(cip);
3308 xfs_iunlock(cip, XFS_ILOCK_SHARED);
3309 continue;
3310 }
3311
3312
3313
3314
3315
3316 if (!xfs_inode_clean(cip)) {
3317 int error;
3318 error = xfs_iflush_int(cip, bp);
3319 if (error) {
3320 xfs_iunlock(cip, XFS_ILOCK_SHARED);
3321 goto cluster_corrupt_out;
3322 }
3323 clcount++;
3324 } else {
3325 xfs_ifunlock(cip);
3326 }
3327 xfs_iunlock(cip, XFS_ILOCK_SHARED);
3328 }
3329
3330 if (clcount) {
3331 XFS_STATS_INC(mp, xs_icluster_flushcnt);
3332 XFS_STATS_ADD(mp, xs_icluster_flushinode, clcount);
3333 }
3334
3335out_free:
3336 rcu_read_unlock();
3337 kmem_free(cilist);
3338out_put:
3339 xfs_perag_put(pag);
3340 return 0;
3341
3342
3343cluster_corrupt_out:
3344
3345
3346
3347
3348 rcu_read_unlock();
3349
3350
3351
3352
3353
3354 bufwasdelwri = (bp->b_flags & _XBF_DELWRI_Q);
3355 if (bufwasdelwri)
3356 xfs_buf_relse(bp);
3357
3358 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3359
3360 if (!bufwasdelwri) {
3361
3362
3363
3364
3365
3366 if (bp->b_iodone) {
3367 bp->b_flags &= ~XBF_DONE;
3368 xfs_buf_stale(bp);
3369 xfs_buf_ioerror(bp, -EIO);
3370 xfs_buf_ioend(bp);
3371 } else {
3372 xfs_buf_stale(bp);
3373 xfs_buf_relse(bp);
3374 }
3375 }
3376
3377
3378
3379
3380 xfs_iflush_abort(cip, false);
3381 kmem_free(cilist);
3382 xfs_perag_put(pag);
3383 return -EFSCORRUPTED;
3384}
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395int
3396xfs_iflush(
3397 struct xfs_inode *ip,
3398 struct xfs_buf **bpp)
3399{
3400 struct xfs_mount *mp = ip->i_mount;
3401 struct xfs_buf *bp = NULL;
3402 struct xfs_dinode *dip;
3403 int error;
3404
3405 XFS_STATS_INC(mp, xs_iflush_count);
3406
3407 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
3408 ASSERT(xfs_isiflocked(ip));
3409 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3410 ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
3411
3412 *bpp = NULL;
3413
3414 xfs_iunpin_wait(ip);
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424 if (xfs_iflags_test(ip, XFS_ISTALE)) {
3425 xfs_ifunlock(ip);
3426 return 0;
3427 }
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437 if (XFS_FORCED_SHUTDOWN(mp)) {
3438 error = -EIO;
3439 goto abort_out;
3440 }
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451 error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &bp, XBF_TRYLOCK,
3452 0);
3453 if (error == -EAGAIN) {
3454 xfs_ifunlock(ip);
3455 return error;
3456 }
3457 if (error)
3458 goto corrupt_out;
3459
3460
3461
3462
3463 error = xfs_iflush_int(ip, bp);
3464 if (error)
3465 goto corrupt_out;
3466
3467
3468
3469
3470
3471 if (xfs_buf_ispinned(bp))
3472 xfs_log_force(mp, 0);
3473
3474
3475
3476
3477
3478 error = xfs_iflush_cluster(ip, bp);
3479 if (error)
3480 goto cluster_corrupt_out;
3481
3482 *bpp = bp;
3483 return 0;
3484
3485corrupt_out:
3486 if (bp)
3487 xfs_buf_relse(bp);
3488 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3489cluster_corrupt_out:
3490 error = -EFSCORRUPTED;
3491abort_out:
3492
3493
3494
3495 xfs_iflush_abort(ip, false);
3496 return error;
3497}
3498
3499
3500
3501
3502
3503bool
3504xfs_inode_verify_forks(
3505 struct xfs_inode *ip)
3506{
3507 struct xfs_ifork *ifp;
3508 xfs_failaddr_t fa;
3509
3510 fa = xfs_ifork_verify_data(ip, &xfs_default_ifork_ops);
3511 if (fa) {
3512 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
3513 xfs_inode_verifier_error(ip, -EFSCORRUPTED, "data fork",
3514 ifp->if_u1.if_data, ifp->if_bytes, fa);
3515 return false;
3516 }
3517
3518 fa = xfs_ifork_verify_attr(ip, &xfs_default_ifork_ops);
3519 if (fa) {
3520 ifp = XFS_IFORK_PTR(ip, XFS_ATTR_FORK);
3521 xfs_inode_verifier_error(ip, -EFSCORRUPTED, "attr fork",
3522 ifp ? ifp->if_u1.if_data : NULL,
3523 ifp ? ifp->if_bytes : 0, fa);
3524 return false;
3525 }
3526 return true;
3527}
3528
3529STATIC int
3530xfs_iflush_int(
3531 struct xfs_inode *ip,
3532 struct xfs_buf *bp)
3533{
3534 struct xfs_inode_log_item *iip = ip->i_itemp;
3535 struct xfs_dinode *dip;
3536 struct xfs_mount *mp = ip->i_mount;
3537
3538 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
3539 ASSERT(xfs_isiflocked(ip));
3540 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3541 ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
3542 ASSERT(iip != NULL && iip->ili_fields != 0);
3543 ASSERT(ip->i_d.di_version > 1);
3544
3545
3546 dip = xfs_buf_offset(bp, ip->i_imap.im_boffset);
3547
3548 if (XFS_TEST_ERROR(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC),
3549 mp, XFS_ERRTAG_IFLUSH_1)) {
3550 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3551 "%s: Bad inode %Lu magic number 0x%x, ptr "PTR_FMT,
3552 __func__, ip->i_ino, be16_to_cpu(dip->di_magic), dip);
3553 goto corrupt_out;
3554 }
3555 if (S_ISREG(VFS_I(ip)->i_mode)) {
3556 if (XFS_TEST_ERROR(
3557 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3558 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
3559 mp, XFS_ERRTAG_IFLUSH_3)) {
3560 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3561 "%s: Bad regular inode %Lu, ptr "PTR_FMT,
3562 __func__, ip->i_ino, ip);
3563 goto corrupt_out;
3564 }
3565 } else if (S_ISDIR(VFS_I(ip)->i_mode)) {
3566 if (XFS_TEST_ERROR(
3567 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3568 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
3569 (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL),
3570 mp, XFS_ERRTAG_IFLUSH_4)) {
3571 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3572 "%s: Bad directory inode %Lu, ptr "PTR_FMT,
3573 __func__, ip->i_ino, ip);
3574 goto corrupt_out;
3575 }
3576 }
3577 if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents >
3578 ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5)) {
3579 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3580 "%s: detected corrupt incore inode %Lu, "
3581 "total extents = %d, nblocks = %Ld, ptr "PTR_FMT,
3582 __func__, ip->i_ino,
3583 ip->i_d.di_nextents + ip->i_d.di_anextents,
3584 ip->i_d.di_nblocks, ip);
3585 goto corrupt_out;
3586 }
3587 if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize,
3588 mp, XFS_ERRTAG_IFLUSH_6)) {
3589 xfs_alert_tag(mp, XFS_PTAG_IFLUSH,
3590 "%s: bad inode %Lu, forkoff 0x%x, ptr "PTR_FMT,
3591 __func__, ip->i_ino, ip->i_d.di_forkoff, ip);
3592 goto corrupt_out;
3593 }
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604 if (ip->i_d.di_version < 3)
3605 ip->i_d.di_flushiter++;
3606
3607
3608 if (!xfs_inode_verify_forks(ip))
3609 goto corrupt_out;
3610
3611
3612
3613
3614
3615
3616 xfs_inode_to_disk(ip, dip, iip->ili_item.li_lsn);
3617
3618
3619 if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
3620 ip->i_d.di_flushiter = 0;
3621
3622 xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
3623 if (XFS_IFORK_Q(ip))
3624 xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);
3625 xfs_inobp_check(mp, bp);
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652 iip->ili_last_fields = iip->ili_fields;
3653 iip->ili_fields = 0;
3654 iip->ili_fsync_fields = 0;
3655 iip->ili_logged = 1;
3656
3657 xfs_trans_ail_copy_lsn(mp->m_ail, &iip->ili_flush_lsn,
3658 &iip->ili_item.li_lsn);
3659
3660
3661
3662
3663
3664
3665
3666 xfs_buf_attach_iodone(bp, xfs_iflush_done, &iip->ili_item);
3667
3668
3669 xfs_dinode_calc_crc(mp, dip);
3670
3671 ASSERT(!list_empty(&bp->b_li_list));
3672 ASSERT(bp->b_iodone != NULL);
3673 return 0;
3674
3675corrupt_out:
3676 return -EFSCORRUPTED;
3677}
3678