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