1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/fs.h>
27#include <linux/types.h>
28#include <linux/slab.h>
29#include <linux/highmem.h>
30#include <linux/pagemap.h>
31#include <linux/quotaops.h>
32
33#include <asm/byteorder.h>
34
35#define MLOG_MASK_PREFIX ML_INODE
36#include <cluster/masklog.h>
37
38#include "ocfs2.h"
39
40#include "alloc.h"
41#include "dir.h"
42#include "blockcheck.h"
43#include "dlmglue.h"
44#include "extent_map.h"
45#include "file.h"
46#include "heartbeat.h"
47#include "inode.h"
48#include "journal.h"
49#include "namei.h"
50#include "suballoc.h"
51#include "super.h"
52#include "symlink.h"
53#include "sysfile.h"
54#include "uptodate.h"
55#include "xattr.h"
56#include "refcounttree.h"
57
58#include "buffer_head_io.h"
59
60struct ocfs2_find_inode_args
61{
62 u64 fi_blkno;
63 unsigned long fi_ino;
64 unsigned int fi_flags;
65 unsigned int fi_sysfile_type;
66};
67
68static struct lock_class_key ocfs2_sysfile_lock_key[NUM_SYSTEM_INODES];
69
70static int ocfs2_read_locked_inode(struct inode *inode,
71 struct ocfs2_find_inode_args *args);
72static int ocfs2_init_locked_inode(struct inode *inode, void *opaque);
73static int ocfs2_find_actor(struct inode *inode, void *opaque);
74static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
75 struct inode *inode,
76 struct buffer_head *fe_bh);
77
78void ocfs2_set_inode_flags(struct inode *inode)
79{
80 unsigned int flags = OCFS2_I(inode)->ip_attr;
81
82 inode->i_flags &= ~(S_IMMUTABLE |
83 S_SYNC | S_APPEND | S_NOATIME | S_DIRSYNC);
84
85 if (flags & OCFS2_IMMUTABLE_FL)
86 inode->i_flags |= S_IMMUTABLE;
87
88 if (flags & OCFS2_SYNC_FL)
89 inode->i_flags |= S_SYNC;
90 if (flags & OCFS2_APPEND_FL)
91 inode->i_flags |= S_APPEND;
92 if (flags & OCFS2_NOATIME_FL)
93 inode->i_flags |= S_NOATIME;
94 if (flags & OCFS2_DIRSYNC_FL)
95 inode->i_flags |= S_DIRSYNC;
96}
97
98
99void ocfs2_get_inode_flags(struct ocfs2_inode_info *oi)
100{
101 unsigned int flags = oi->vfs_inode.i_flags;
102
103 oi->ip_attr &= ~(OCFS2_SYNC_FL|OCFS2_APPEND_FL|
104 OCFS2_IMMUTABLE_FL|OCFS2_NOATIME_FL|OCFS2_DIRSYNC_FL);
105 if (flags & S_SYNC)
106 oi->ip_attr |= OCFS2_SYNC_FL;
107 if (flags & S_APPEND)
108 oi->ip_attr |= OCFS2_APPEND_FL;
109 if (flags & S_IMMUTABLE)
110 oi->ip_attr |= OCFS2_IMMUTABLE_FL;
111 if (flags & S_NOATIME)
112 oi->ip_attr |= OCFS2_NOATIME_FL;
113 if (flags & S_DIRSYNC)
114 oi->ip_attr |= OCFS2_DIRSYNC_FL;
115}
116
117struct inode *ocfs2_ilookup(struct super_block *sb, u64 blkno)
118{
119 struct ocfs2_find_inode_args args;
120
121 args.fi_blkno = blkno;
122 args.fi_flags = 0;
123 args.fi_ino = ino_from_blkno(sb, blkno);
124 args.fi_sysfile_type = 0;
125
126 return ilookup5(sb, blkno, ocfs2_find_actor, &args);
127}
128struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, unsigned flags,
129 int sysfile_type)
130{
131 struct inode *inode = NULL;
132 struct super_block *sb = osb->sb;
133 struct ocfs2_find_inode_args args;
134
135 mlog_entry("(blkno = %llu)\n", (unsigned long long)blkno);
136
137
138
139
140 if (blkno == 0) {
141 inode = ERR_PTR(-EINVAL);
142 mlog_errno(PTR_ERR(inode));
143 goto bail;
144 }
145
146 args.fi_blkno = blkno;
147 args.fi_flags = flags;
148 args.fi_ino = ino_from_blkno(sb, blkno);
149 args.fi_sysfile_type = sysfile_type;
150
151 inode = iget5_locked(sb, args.fi_ino, ocfs2_find_actor,
152 ocfs2_init_locked_inode, &args);
153
154
155
156 if (inode && inode->i_state & I_NEW) {
157 mlog(0, "Inode was not in inode cache, reading it.\n");
158 ocfs2_read_locked_inode(inode, &args);
159 unlock_new_inode(inode);
160 }
161 if (inode == NULL) {
162 inode = ERR_PTR(-ENOMEM);
163 mlog_errno(PTR_ERR(inode));
164 goto bail;
165 }
166 if (is_bad_inode(inode)) {
167 iput(inode);
168 inode = ERR_PTR(-ESTALE);
169 goto bail;
170 }
171
172bail:
173 if (!IS_ERR(inode)) {
174 mlog(0, "returning inode with number %llu\n",
175 (unsigned long long)OCFS2_I(inode)->ip_blkno);
176 mlog_exit_ptr(inode);
177 }
178
179 return inode;
180}
181
182
183
184
185
186
187
188
189
190static int ocfs2_find_actor(struct inode *inode, void *opaque)
191{
192 struct ocfs2_find_inode_args *args = NULL;
193 struct ocfs2_inode_info *oi = OCFS2_I(inode);
194 int ret = 0;
195
196 mlog_entry("(0x%p, %lu, 0x%p)\n", inode, inode->i_ino, opaque);
197
198 args = opaque;
199
200 mlog_bug_on_msg(!inode, "No inode in find actor!\n");
201
202 if (oi->ip_blkno != args->fi_blkno)
203 goto bail;
204
205 ret = 1;
206bail:
207 mlog_exit(ret);
208 return ret;
209}
210
211
212
213
214
215
216static int ocfs2_init_locked_inode(struct inode *inode, void *opaque)
217{
218 struct ocfs2_find_inode_args *args = opaque;
219 static struct lock_class_key ocfs2_quota_ip_alloc_sem_key,
220 ocfs2_file_ip_alloc_sem_key;
221
222 mlog_entry("inode = %p, opaque = %p\n", inode, opaque);
223
224 inode->i_ino = args->fi_ino;
225 OCFS2_I(inode)->ip_blkno = args->fi_blkno;
226 if (args->fi_sysfile_type != 0)
227 lockdep_set_class(&inode->i_mutex,
228 &ocfs2_sysfile_lock_key[args->fi_sysfile_type]);
229 if (args->fi_sysfile_type == USER_QUOTA_SYSTEM_INODE ||
230 args->fi_sysfile_type == GROUP_QUOTA_SYSTEM_INODE ||
231 args->fi_sysfile_type == LOCAL_USER_QUOTA_SYSTEM_INODE ||
232 args->fi_sysfile_type == LOCAL_GROUP_QUOTA_SYSTEM_INODE)
233 lockdep_set_class(&OCFS2_I(inode)->ip_alloc_sem,
234 &ocfs2_quota_ip_alloc_sem_key);
235 else
236 lockdep_set_class(&OCFS2_I(inode)->ip_alloc_sem,
237 &ocfs2_file_ip_alloc_sem_key);
238
239 mlog_exit(0);
240 return 0;
241}
242
243void ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
244 int create_ino)
245{
246 struct super_block *sb;
247 struct ocfs2_super *osb;
248 int use_plocks = 1;
249
250 mlog_entry("(0x%p, size:%llu)\n", inode,
251 (unsigned long long)le64_to_cpu(fe->i_size));
252
253 sb = inode->i_sb;
254 osb = OCFS2_SB(sb);
255
256 if ((osb->s_mount_opt & OCFS2_MOUNT_LOCALFLOCKS) ||
257 ocfs2_mount_local(osb) || !ocfs2_stack_supports_plocks())
258 use_plocks = 0;
259
260
261
262
263
264 BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
265
266
267
268 BUG_ON(!(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL)));
269 BUG_ON(le32_to_cpu(fe->i_fs_generation) != osb->fs_generation);
270
271
272 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
273 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
274 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features);
275
276 inode->i_version = 1;
277 inode->i_generation = le32_to_cpu(fe->i_generation);
278 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
279 inode->i_mode = le16_to_cpu(fe->i_mode);
280 inode->i_uid = le32_to_cpu(fe->i_uid);
281 inode->i_gid = le32_to_cpu(fe->i_gid);
282
283
284 if (S_ISLNK(inode->i_mode) && !fe->i_clusters)
285 inode->i_blocks = 0;
286 else
287 inode->i_blocks = ocfs2_inode_sector_count(inode);
288 inode->i_mapping->a_ops = &ocfs2_aops;
289 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
290 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
291 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
292 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
293 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
294 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
295
296 if (OCFS2_I(inode)->ip_blkno != le64_to_cpu(fe->i_blkno))
297 mlog(ML_ERROR,
298 "ip_blkno %llu != i_blkno %llu!\n",
299 (unsigned long long)OCFS2_I(inode)->ip_blkno,
300 (unsigned long long)le64_to_cpu(fe->i_blkno));
301
302 inode->i_nlink = ocfs2_read_links_count(fe);
303
304 if (fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) {
305 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SYSTEM_FILE;
306 inode->i_flags |= S_NOQUOTA;
307 }
308
309 if (fe->i_flags & cpu_to_le32(OCFS2_LOCAL_ALLOC_FL)) {
310 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
311 mlog(0, "local alloc inode: i_ino=%lu\n", inode->i_ino);
312 } else if (fe->i_flags & cpu_to_le32(OCFS2_BITMAP_FL)) {
313 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
314 } else if (fe->i_flags & cpu_to_le32(OCFS2_QUOTA_FL)) {
315 inode->i_flags |= S_NOQUOTA;
316 } else if (fe->i_flags & cpu_to_le32(OCFS2_SUPER_BLOCK_FL)) {
317 mlog(0, "superblock inode: i_ino=%lu\n", inode->i_ino);
318
319
320 BUG();
321 }
322
323 switch (inode->i_mode & S_IFMT) {
324 case S_IFREG:
325 if (use_plocks)
326 inode->i_fop = &ocfs2_fops;
327 else
328 inode->i_fop = &ocfs2_fops_no_plocks;
329 inode->i_op = &ocfs2_file_iops;
330 i_size_write(inode, le64_to_cpu(fe->i_size));
331 break;
332 case S_IFDIR:
333 inode->i_op = &ocfs2_dir_iops;
334 if (use_plocks)
335 inode->i_fop = &ocfs2_dops;
336 else
337 inode->i_fop = &ocfs2_dops_no_plocks;
338 i_size_write(inode, le64_to_cpu(fe->i_size));
339 break;
340 case S_IFLNK:
341 if (ocfs2_inode_is_fast_symlink(inode))
342 inode->i_op = &ocfs2_fast_symlink_inode_operations;
343 else
344 inode->i_op = &ocfs2_symlink_inode_operations;
345 i_size_write(inode, le64_to_cpu(fe->i_size));
346 break;
347 default:
348 inode->i_op = &ocfs2_special_file_iops;
349 init_special_inode(inode, inode->i_mode,
350 inode->i_rdev);
351 break;
352 }
353
354 if (create_ino) {
355 inode->i_ino = ino_from_blkno(inode->i_sb,
356 le64_to_cpu(fe->i_blkno));
357
358
359
360
361
362
363 BUG_ON(le32_to_cpu(fe->i_flags) & OCFS2_SYSTEM_FL);
364
365 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres,
366 OCFS2_LOCK_TYPE_META, 0, inode);
367
368 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres,
369 OCFS2_LOCK_TYPE_OPEN, 0, inode);
370 }
371
372 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_rw_lockres,
373 OCFS2_LOCK_TYPE_RW, inode->i_generation,
374 inode);
375
376 ocfs2_set_inode_flags(inode);
377
378 OCFS2_I(inode)->ip_last_used_slot = 0;
379 OCFS2_I(inode)->ip_last_used_group = 0;
380 mlog_exit_void();
381}
382
383static int ocfs2_read_locked_inode(struct inode *inode,
384 struct ocfs2_find_inode_args *args)
385{
386 struct super_block *sb;
387 struct ocfs2_super *osb;
388 struct ocfs2_dinode *fe;
389 struct buffer_head *bh = NULL;
390 int status, can_lock;
391 u32 generation = 0;
392
393 mlog_entry("(0x%p, 0x%p)\n", inode, args);
394
395 status = -EINVAL;
396 if (inode == NULL || inode->i_sb == NULL) {
397 mlog(ML_ERROR, "bad inode\n");
398 return status;
399 }
400 sb = inode->i_sb;
401 osb = OCFS2_SB(sb);
402
403 if (!args) {
404 mlog(ML_ERROR, "bad inode args\n");
405 make_bad_inode(inode);
406 return status;
407 }
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438 can_lock = !(args->fi_flags & OCFS2_FI_FLAG_SYSFILE)
439 && !(args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY)
440 && !ocfs2_mount_local(osb);
441
442
443
444
445
446
447
448
449 if (args->fi_flags & OCFS2_FI_FLAG_SYSFILE)
450 generation = osb->fs_generation;
451
452 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres,
453 OCFS2_LOCK_TYPE_META,
454 generation, inode);
455
456 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres,
457 OCFS2_LOCK_TYPE_OPEN,
458 0, inode);
459
460 if (can_lock) {
461 status = ocfs2_open_lock(inode);
462 if (status) {
463 make_bad_inode(inode);
464 mlog_errno(status);
465 return status;
466 }
467 status = ocfs2_inode_lock(inode, NULL, 0);
468 if (status) {
469 make_bad_inode(inode);
470 mlog_errno(status);
471 return status;
472 }
473 }
474
475 if (args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) {
476 status = ocfs2_try_open_lock(inode, 0);
477 if (status) {
478 make_bad_inode(inode);
479 return status;
480 }
481 }
482
483 if (can_lock) {
484 status = ocfs2_read_inode_block_full(inode, &bh,
485 OCFS2_BH_IGNORE_CACHE);
486 } else {
487 status = ocfs2_read_blocks_sync(osb, args->fi_blkno, 1, &bh);
488 if (!status)
489 status = ocfs2_validate_inode_block(osb->sb, bh);
490 }
491 if (status < 0) {
492 mlog_errno(status);
493 goto bail;
494 }
495
496 status = -EINVAL;
497 fe = (struct ocfs2_dinode *) bh->b_data;
498
499
500
501
502
503
504 mlog_bug_on_msg(!!(fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) !=
505 !!(args->fi_flags & OCFS2_FI_FLAG_SYSFILE),
506 "Inode %llu: system file state is ambigous\n",
507 (unsigned long long)args->fi_blkno);
508
509 if (S_ISCHR(le16_to_cpu(fe->i_mode)) ||
510 S_ISBLK(le16_to_cpu(fe->i_mode)))
511 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
512
513 ocfs2_populate_inode(inode, fe, 0);
514
515 BUG_ON(args->fi_blkno != le64_to_cpu(fe->i_blkno));
516
517 status = 0;
518
519bail:
520 if (can_lock)
521 ocfs2_inode_unlock(inode, 0);
522
523 if (status < 0)
524 make_bad_inode(inode);
525
526 if (args && bh)
527 brelse(bh);
528
529 mlog_exit(status);
530 return status;
531}
532
533void ocfs2_sync_blockdev(struct super_block *sb)
534{
535 sync_blockdev(sb->s_bdev);
536}
537
538static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
539 struct inode *inode,
540 struct buffer_head *fe_bh)
541{
542 int status = 0;
543 struct ocfs2_truncate_context *tc = NULL;
544 struct ocfs2_dinode *fe;
545 handle_t *handle = NULL;
546
547 mlog_entry_void();
548
549 fe = (struct ocfs2_dinode *) fe_bh->b_data;
550
551
552
553
554
555 if (fe->i_clusters) {
556 if (ocfs2_should_order_data(inode))
557 ocfs2_begin_ordered_truncate(inode, 0);
558
559 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
560 if (IS_ERR(handle)) {
561 status = PTR_ERR(handle);
562 mlog_errno(status);
563 goto out;
564 }
565
566 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
567 fe_bh,
568 OCFS2_JOURNAL_ACCESS_WRITE);
569 if (status < 0) {
570 mlog_errno(status);
571 goto out;
572 }
573
574 i_size_write(inode, 0);
575
576 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
577 if (status < 0) {
578 mlog_errno(status);
579 goto out;
580 }
581
582 ocfs2_commit_trans(osb, handle);
583 handle = NULL;
584
585 status = ocfs2_prepare_truncate(osb, inode, fe_bh, &tc);
586 if (status < 0) {
587 mlog_errno(status);
588 goto out;
589 }
590
591 status = ocfs2_commit_truncate(osb, inode, fe_bh, tc);
592 if (status < 0) {
593 mlog_errno(status);
594 goto out;
595 }
596 }
597
598out:
599 if (handle)
600 ocfs2_commit_trans(osb, handle);
601 mlog_exit(status);
602 return status;
603}
604
605static int ocfs2_remove_inode(struct inode *inode,
606 struct buffer_head *di_bh,
607 struct inode *orphan_dir_inode,
608 struct buffer_head *orphan_dir_bh)
609{
610 int status;
611 struct inode *inode_alloc_inode = NULL;
612 struct buffer_head *inode_alloc_bh = NULL;
613 handle_t *handle;
614 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
615 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
616
617 inode_alloc_inode =
618 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE,
619 le16_to_cpu(di->i_suballoc_slot));
620 if (!inode_alloc_inode) {
621 status = -EEXIST;
622 mlog_errno(status);
623 goto bail;
624 }
625
626 mutex_lock(&inode_alloc_inode->i_mutex);
627 status = ocfs2_inode_lock(inode_alloc_inode, &inode_alloc_bh, 1);
628 if (status < 0) {
629 mutex_unlock(&inode_alloc_inode->i_mutex);
630
631 mlog_errno(status);
632 goto bail;
633 }
634
635 handle = ocfs2_start_trans(osb, OCFS2_DELETE_INODE_CREDITS +
636 ocfs2_quota_trans_credits(inode->i_sb));
637 if (IS_ERR(handle)) {
638 status = PTR_ERR(handle);
639 mlog_errno(status);
640 goto bail_unlock;
641 }
642
643 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
644 orphan_dir_bh);
645 if (status < 0) {
646 mlog_errno(status);
647 goto bail_commit;
648 }
649
650
651 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
652 OCFS2_JOURNAL_ACCESS_WRITE);
653 if (status < 0) {
654 mlog_errno(status);
655 goto bail_commit;
656 }
657
658 di->i_dtime = cpu_to_le64(CURRENT_TIME.tv_sec);
659 di->i_flags &= cpu_to_le32(~(OCFS2_VALID_FL | OCFS2_ORPHANED_FL));
660
661 status = ocfs2_journal_dirty(handle, di_bh);
662 if (status < 0) {
663 mlog_errno(status);
664 goto bail_commit;
665 }
666
667 ocfs2_remove_from_cache(INODE_CACHE(inode), di_bh);
668 vfs_dq_free_inode(inode);
669
670 status = ocfs2_free_dinode(handle, inode_alloc_inode,
671 inode_alloc_bh, di);
672 if (status < 0)
673 mlog_errno(status);
674
675bail_commit:
676 ocfs2_commit_trans(osb, handle);
677bail_unlock:
678 ocfs2_inode_unlock(inode_alloc_inode, 1);
679 mutex_unlock(&inode_alloc_inode->i_mutex);
680 brelse(inode_alloc_bh);
681bail:
682 iput(inode_alloc_inode);
683
684 return status;
685}
686
687
688
689
690
691
692
693static int ocfs2_check_orphan_recovery_state(struct ocfs2_super *osb,
694 int slot)
695{
696 int ret = 0;
697
698 spin_lock(&osb->osb_lock);
699 if (ocfs2_node_map_test_bit(osb, &osb->osb_recovering_orphan_dirs, slot)) {
700 mlog(0, "Recovery is happening on orphan dir %d, will skip "
701 "this inode\n", slot);
702 ret = -EDEADLK;
703 goto out;
704 }
705
706
707 osb->osb_orphan_wipes[slot]++;
708out:
709 spin_unlock(&osb->osb_lock);
710 return ret;
711}
712
713static void ocfs2_signal_wipe_completion(struct ocfs2_super *osb,
714 int slot)
715{
716 spin_lock(&osb->osb_lock);
717 osb->osb_orphan_wipes[slot]--;
718 spin_unlock(&osb->osb_lock);
719
720 wake_up(&osb->osb_wipe_event);
721}
722
723static int ocfs2_wipe_inode(struct inode *inode,
724 struct buffer_head *di_bh)
725{
726 int status, orphaned_slot;
727 struct inode *orphan_dir_inode = NULL;
728 struct buffer_head *orphan_dir_bh = NULL;
729 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
730 struct ocfs2_dinode *di;
731
732 di = (struct ocfs2_dinode *) di_bh->b_data;
733 orphaned_slot = le16_to_cpu(di->i_orphaned_slot);
734
735 status = ocfs2_check_orphan_recovery_state(osb, orphaned_slot);
736 if (status)
737 return status;
738
739 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
740 ORPHAN_DIR_SYSTEM_INODE,
741 orphaned_slot);
742 if (!orphan_dir_inode) {
743 status = -EEXIST;
744 mlog_errno(status);
745 goto bail;
746 }
747
748
749
750
751 mutex_lock(&orphan_dir_inode->i_mutex);
752 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
753 if (status < 0) {
754 mutex_unlock(&orphan_dir_inode->i_mutex);
755
756 mlog_errno(status);
757 goto bail;
758 }
759
760
761
762
763
764 status = ocfs2_truncate_for_delete(osb, inode, di_bh);
765 if (status < 0) {
766 mlog_errno(status);
767 goto bail_unlock_dir;
768 }
769
770
771 if (S_ISDIR(inode->i_mode)) {
772 status = ocfs2_dx_dir_truncate(inode, di_bh);
773 if (status) {
774 mlog_errno(status);
775 goto bail_unlock_dir;
776 }
777 }
778
779
780 status = ocfs2_xattr_remove(inode, di_bh);
781 if (status < 0) {
782 mlog_errno(status);
783 goto bail_unlock_dir;
784 }
785
786 status = ocfs2_remove_refcount_tree(inode, di_bh);
787 if (status < 0) {
788 mlog_errno(status);
789 goto bail_unlock_dir;
790 }
791
792 status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode,
793 orphan_dir_bh);
794 if (status < 0)
795 mlog_errno(status);
796
797bail_unlock_dir:
798 ocfs2_inode_unlock(orphan_dir_inode, 1);
799 mutex_unlock(&orphan_dir_inode->i_mutex);
800 brelse(orphan_dir_bh);
801bail:
802 iput(orphan_dir_inode);
803 ocfs2_signal_wipe_completion(osb, orphaned_slot);
804
805 return status;
806}
807
808
809
810static int ocfs2_inode_is_valid_to_delete(struct inode *inode)
811{
812 int ret = 0;
813 struct ocfs2_inode_info *oi = OCFS2_I(inode);
814 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
815
816
817
818 if (inode == osb->root_inode) {
819 mlog(ML_ERROR, "Skipping delete of root inode.\n");
820 goto bail;
821 }
822
823
824
825
826
827
828 if (current == osb->dc_task) {
829 mlog(0, "Skipping delete of %lu because we're currently "
830 "in downconvert\n", inode->i_ino);
831 goto bail;
832 }
833
834 spin_lock(&oi->ip_lock);
835
836
837
838 if (oi->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
839 mlog(ML_ERROR, "Skipping delete of system file %llu\n",
840 (unsigned long long)oi->ip_blkno);
841 goto bail_unlock;
842 }
843
844
845
846
847 if (oi->ip_flags & OCFS2_INODE_SKIP_DELETE) {
848 mlog(0, "Skipping delete of %lu because another node "
849 "has done this for us.\n", inode->i_ino);
850 goto bail_unlock;
851 }
852
853 ret = 1;
854bail_unlock:
855 spin_unlock(&oi->ip_lock);
856bail:
857 return ret;
858}
859
860
861
862
863
864static int ocfs2_query_inode_wipe(struct inode *inode,
865 struct buffer_head *di_bh,
866 int *wipe)
867{
868 int status = 0;
869 struct ocfs2_inode_info *oi = OCFS2_I(inode);
870 struct ocfs2_dinode *di;
871
872 *wipe = 0;
873
874
875
876
877 if (!ocfs2_inode_is_valid_to_delete(inode)) {
878 mlog(0, "Skipping delete of %llu because flags changed\n",
879 (unsigned long long)oi->ip_blkno);
880 goto bail;
881 }
882
883
884
885 if (inode->i_nlink) {
886 mlog(0, "Skipping delete of %llu because nlink = %u\n",
887 (unsigned long long)oi->ip_blkno, inode->i_nlink);
888 goto bail;
889 }
890
891
892 di = (struct ocfs2_dinode *) di_bh->b_data;
893 if (!(di->i_flags & cpu_to_le32(OCFS2_ORPHANED_FL))) {
894
895 status = -EEXIST;
896 mlog(ML_ERROR,
897 "Inode %llu (on-disk %llu) not orphaned! "
898 "Disk flags 0x%x, inode flags 0x%x\n",
899 (unsigned long long)oi->ip_blkno,
900 (unsigned long long)le64_to_cpu(di->i_blkno),
901 le32_to_cpu(di->i_flags), oi->ip_flags);
902 goto bail;
903 }
904
905
906 if (di->i_dtime) {
907 status = -EEXIST;
908 mlog_errno(status);
909 goto bail;
910 }
911
912
913
914
915
916
917
918
919
920
921
922
923
924 status = ocfs2_try_open_lock(inode, 1);
925 if (status == -EAGAIN) {
926 status = 0;
927 mlog(0, "Skipping delete of %llu because it is in use on "
928 "other nodes\n", (unsigned long long)oi->ip_blkno);
929 goto bail;
930 }
931 if (status < 0) {
932 mlog_errno(status);
933 goto bail;
934 }
935
936 *wipe = 1;
937 mlog(0, "Inode %llu is ok to wipe from orphan dir %u\n",
938 (unsigned long long)oi->ip_blkno,
939 le16_to_cpu(di->i_orphaned_slot));
940
941bail:
942 return status;
943}
944
945
946
947
948static void ocfs2_cleanup_delete_inode(struct inode *inode,
949 int sync_data)
950{
951 mlog(0, "Cleanup inode %llu, sync = %d\n",
952 (unsigned long long)OCFS2_I(inode)->ip_blkno, sync_data);
953 if (sync_data)
954 write_inode_now(inode, 1);
955 truncate_inode_pages(&inode->i_data, 0);
956}
957
958void ocfs2_delete_inode(struct inode *inode)
959{
960 int wipe, status;
961 sigset_t blocked, oldset;
962 struct buffer_head *di_bh = NULL;
963
964 mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
965
966
967
968
969 if (is_bad_inode(inode) || !OCFS2_I(inode)->ip_blkno) {
970 mlog(0, "Skipping delete of bad inode\n");
971 goto bail;
972 }
973
974 if (!ocfs2_inode_is_valid_to_delete(inode)) {
975
976
977
978 ocfs2_cleanup_delete_inode(inode, 0);
979 goto bail;
980 }
981
982
983
984
985
986 sigfillset(&blocked);
987 status = sigprocmask(SIG_BLOCK, &blocked, &oldset);
988 if (status < 0) {
989 mlog_errno(status);
990 ocfs2_cleanup_delete_inode(inode, 1);
991 goto bail;
992 }
993
994
995
996
997
998
999 status = ocfs2_nfs_sync_lock(OCFS2_SB(inode->i_sb), 0);
1000 if (status < 0) {
1001 mlog(ML_ERROR, "getting nfs sync lock(PR) failed %d\n", status);
1002 ocfs2_cleanup_delete_inode(inode, 0);
1003 goto bail_unblock;
1004 }
1005
1006
1007
1008
1009
1010
1011
1012
1013 status = ocfs2_inode_lock(inode, &di_bh, 1);
1014 if (status < 0) {
1015 if (status != -ENOENT)
1016 mlog_errno(status);
1017 ocfs2_cleanup_delete_inode(inode, 0);
1018 goto bail_unlock_nfs_sync;
1019 }
1020
1021
1022
1023 status = ocfs2_query_inode_wipe(inode, di_bh, &wipe);
1024 if (!wipe || status < 0) {
1025
1026
1027
1028 if (status < 0)
1029 mlog_errno(status);
1030
1031
1032
1033
1034 ocfs2_cleanup_delete_inode(inode, 1);
1035 goto bail_unlock_inode;
1036 }
1037
1038 ocfs2_cleanup_delete_inode(inode, 0);
1039
1040 status = ocfs2_wipe_inode(inode, di_bh);
1041 if (status < 0) {
1042 if (status != -EDEADLK)
1043 mlog_errno(status);
1044 goto bail_unlock_inode;
1045 }
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_DELETED;
1057
1058bail_unlock_inode:
1059 ocfs2_inode_unlock(inode, 1);
1060 brelse(di_bh);
1061
1062bail_unlock_nfs_sync:
1063 ocfs2_nfs_sync_unlock(OCFS2_SB(inode->i_sb), 0);
1064
1065bail_unblock:
1066 status = sigprocmask(SIG_SETMASK, &oldset, NULL);
1067 if (status < 0)
1068 mlog_errno(status);
1069bail:
1070 clear_inode(inode);
1071 mlog_exit_void();
1072}
1073
1074void ocfs2_clear_inode(struct inode *inode)
1075{
1076 int status;
1077 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1078
1079 mlog_entry_void();
1080
1081 if (!inode)
1082 goto bail;
1083
1084 mlog(0, "Clearing inode: %llu, nlink = %u\n",
1085 (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_nlink);
1086
1087 mlog_bug_on_msg(OCFS2_SB(inode->i_sb) == NULL,
1088 "Inode=%lu\n", inode->i_ino);
1089
1090
1091
1092 ocfs2_open_unlock(inode);
1093
1094
1095
1096 ocfs2_mark_lockres_freeing(&oi->ip_rw_lockres);
1097 ocfs2_mark_lockres_freeing(&oi->ip_inode_lockres);
1098 ocfs2_mark_lockres_freeing(&oi->ip_open_lockres);
1099
1100
1101
1102
1103
1104
1105
1106 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED))
1107 ocfs2_checkpoint_inode(inode);
1108
1109 mlog_bug_on_msg(!list_empty(&oi->ip_io_markers),
1110 "Clear inode of %llu, inode has io markers\n",
1111 (unsigned long long)oi->ip_blkno);
1112
1113 ocfs2_extent_map_trunc(inode, 0);
1114
1115 status = ocfs2_drop_inode_locks(inode);
1116 if (status < 0)
1117 mlog_errno(status);
1118
1119 ocfs2_lock_res_free(&oi->ip_rw_lockres);
1120 ocfs2_lock_res_free(&oi->ip_inode_lockres);
1121 ocfs2_lock_res_free(&oi->ip_open_lockres);
1122
1123 ocfs2_metadata_cache_exit(INODE_CACHE(inode));
1124
1125 mlog_bug_on_msg(INODE_CACHE(inode)->ci_num_cached,
1126 "Clear inode of %llu, inode has %u cache items\n",
1127 (unsigned long long)oi->ip_blkno,
1128 INODE_CACHE(inode)->ci_num_cached);
1129
1130 mlog_bug_on_msg(!(INODE_CACHE(inode)->ci_flags & OCFS2_CACHE_FL_INLINE),
1131 "Clear inode of %llu, inode has a bad flag\n",
1132 (unsigned long long)oi->ip_blkno);
1133
1134 mlog_bug_on_msg(spin_is_locked(&oi->ip_lock),
1135 "Clear inode of %llu, inode is locked\n",
1136 (unsigned long long)oi->ip_blkno);
1137
1138 mlog_bug_on_msg(!mutex_trylock(&oi->ip_io_mutex),
1139 "Clear inode of %llu, io_mutex is locked\n",
1140 (unsigned long long)oi->ip_blkno);
1141 mutex_unlock(&oi->ip_io_mutex);
1142
1143
1144
1145
1146
1147 mlog_bug_on_msg(!down_write_trylock(&oi->ip_alloc_sem),
1148 "Clear inode of %llu, alloc_sem is locked\n",
1149 (unsigned long long)oi->ip_blkno);
1150 up_write(&oi->ip_alloc_sem);
1151
1152 mlog_bug_on_msg(oi->ip_open_count,
1153 "Clear inode of %llu has open count %d\n",
1154 (unsigned long long)oi->ip_blkno, oi->ip_open_count);
1155
1156
1157 oi->ip_flags = 0;
1158 oi->ip_dir_start_lookup = 0;
1159 oi->ip_blkno = 0ULL;
1160
1161
1162
1163
1164
1165
1166 jbd2_journal_release_jbd_inode(OCFS2_SB(inode->i_sb)->journal->j_journal,
1167 &oi->ip_jinode);
1168
1169bail:
1170 mlog_exit_void();
1171}
1172
1173
1174
1175
1176void ocfs2_drop_inode(struct inode *inode)
1177{
1178 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1179
1180 mlog_entry_void();
1181
1182 mlog(0, "Drop inode %llu, nlink = %u, ip_flags = 0x%x\n",
1183 (unsigned long long)oi->ip_blkno, inode->i_nlink, oi->ip_flags);
1184
1185 if (oi->ip_flags & OCFS2_INODE_MAYBE_ORPHANED)
1186 generic_delete_inode(inode);
1187 else
1188 generic_drop_inode(inode);
1189
1190 mlog_exit_void();
1191}
1192
1193
1194
1195
1196int ocfs2_inode_revalidate(struct dentry *dentry)
1197{
1198 struct inode *inode = dentry->d_inode;
1199 int status = 0;
1200
1201 mlog_entry("(inode = 0x%p, ino = %llu)\n", inode,
1202 inode ? (unsigned long long)OCFS2_I(inode)->ip_blkno : 0ULL);
1203
1204 if (!inode) {
1205 mlog(0, "eep, no inode!\n");
1206 status = -ENOENT;
1207 goto bail;
1208 }
1209
1210 spin_lock(&OCFS2_I(inode)->ip_lock);
1211 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
1212 spin_unlock(&OCFS2_I(inode)->ip_lock);
1213 mlog(0, "inode deleted!\n");
1214 status = -ENOENT;
1215 goto bail;
1216 }
1217 spin_unlock(&OCFS2_I(inode)->ip_lock);
1218
1219
1220
1221 status = ocfs2_inode_lock(inode, NULL, 0);
1222 if (status < 0) {
1223 if (status != -ENOENT)
1224 mlog_errno(status);
1225 goto bail;
1226 }
1227 ocfs2_inode_unlock(inode, 0);
1228bail:
1229 mlog_exit(status);
1230
1231 return status;
1232}
1233
1234
1235
1236
1237
1238
1239int ocfs2_mark_inode_dirty(handle_t *handle,
1240 struct inode *inode,
1241 struct buffer_head *bh)
1242{
1243 int status;
1244 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
1245
1246 mlog_entry("(inode %llu)\n",
1247 (unsigned long long)OCFS2_I(inode)->ip_blkno);
1248
1249 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
1250 OCFS2_JOURNAL_ACCESS_WRITE);
1251 if (status < 0) {
1252 mlog_errno(status);
1253 goto leave;
1254 }
1255
1256 spin_lock(&OCFS2_I(inode)->ip_lock);
1257 fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
1258 ocfs2_get_inode_flags(OCFS2_I(inode));
1259 fe->i_attr = cpu_to_le32(OCFS2_I(inode)->ip_attr);
1260 fe->i_dyn_features = cpu_to_le16(OCFS2_I(inode)->ip_dyn_features);
1261 spin_unlock(&OCFS2_I(inode)->ip_lock);
1262
1263 fe->i_size = cpu_to_le64(i_size_read(inode));
1264 ocfs2_set_links_count(fe, inode->i_nlink);
1265 fe->i_uid = cpu_to_le32(inode->i_uid);
1266 fe->i_gid = cpu_to_le32(inode->i_gid);
1267 fe->i_mode = cpu_to_le16(inode->i_mode);
1268 fe->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
1269 fe->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
1270 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
1271 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
1272 fe->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
1273 fe->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
1274
1275 status = ocfs2_journal_dirty(handle, bh);
1276 if (status < 0)
1277 mlog_errno(status);
1278
1279 status = 0;
1280leave:
1281
1282 mlog_exit(status);
1283 return status;
1284}
1285
1286
1287
1288
1289
1290
1291void ocfs2_refresh_inode(struct inode *inode,
1292 struct ocfs2_dinode *fe)
1293{
1294 spin_lock(&OCFS2_I(inode)->ip_lock);
1295
1296 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
1297 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
1298 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features);
1299 ocfs2_set_inode_flags(inode);
1300 i_size_write(inode, le64_to_cpu(fe->i_size));
1301 inode->i_nlink = ocfs2_read_links_count(fe);
1302 inode->i_uid = le32_to_cpu(fe->i_uid);
1303 inode->i_gid = le32_to_cpu(fe->i_gid);
1304 inode->i_mode = le16_to_cpu(fe->i_mode);
1305 if (S_ISLNK(inode->i_mode) && le32_to_cpu(fe->i_clusters) == 0)
1306 inode->i_blocks = 0;
1307 else
1308 inode->i_blocks = ocfs2_inode_sector_count(inode);
1309 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
1310 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
1311 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
1312 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
1313 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
1314 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
1315
1316 spin_unlock(&OCFS2_I(inode)->ip_lock);
1317}
1318
1319int ocfs2_validate_inode_block(struct super_block *sb,
1320 struct buffer_head *bh)
1321{
1322 int rc;
1323 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
1324
1325 mlog(0, "Validating dinode %llu\n",
1326 (unsigned long long)bh->b_blocknr);
1327
1328 BUG_ON(!buffer_uptodate(bh));
1329
1330
1331
1332
1333
1334
1335 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &di->i_check);
1336 if (rc) {
1337 mlog(ML_ERROR, "Checksum failed for dinode %llu\n",
1338 (unsigned long long)bh->b_blocknr);
1339 goto bail;
1340 }
1341
1342
1343
1344
1345
1346 rc = -EINVAL;
1347
1348 if (!OCFS2_IS_VALID_DINODE(di)) {
1349 ocfs2_error(sb, "Invalid dinode #%llu: signature = %.*s\n",
1350 (unsigned long long)bh->b_blocknr, 7,
1351 di->i_signature);
1352 goto bail;
1353 }
1354
1355 if (le64_to_cpu(di->i_blkno) != bh->b_blocknr) {
1356 ocfs2_error(sb, "Invalid dinode #%llu: i_blkno is %llu\n",
1357 (unsigned long long)bh->b_blocknr,
1358 (unsigned long long)le64_to_cpu(di->i_blkno));
1359 goto bail;
1360 }
1361
1362 if (!(di->i_flags & cpu_to_le32(OCFS2_VALID_FL))) {
1363 ocfs2_error(sb,
1364 "Invalid dinode #%llu: OCFS2_VALID_FL not set\n",
1365 (unsigned long long)bh->b_blocknr);
1366 goto bail;
1367 }
1368
1369 if (le32_to_cpu(di->i_fs_generation) !=
1370 OCFS2_SB(sb)->fs_generation) {
1371 ocfs2_error(sb,
1372 "Invalid dinode #%llu: fs_generation is %u\n",
1373 (unsigned long long)bh->b_blocknr,
1374 le32_to_cpu(di->i_fs_generation));
1375 goto bail;
1376 }
1377
1378 rc = 0;
1379
1380bail:
1381 return rc;
1382}
1383
1384int ocfs2_read_inode_block_full(struct inode *inode, struct buffer_head **bh,
1385 int flags)
1386{
1387 int rc;
1388 struct buffer_head *tmp = *bh;
1389
1390 rc = ocfs2_read_blocks(INODE_CACHE(inode), OCFS2_I(inode)->ip_blkno,
1391 1, &tmp, flags, ocfs2_validate_inode_block);
1392
1393
1394 if (!rc && !*bh)
1395 *bh = tmp;
1396
1397 return rc;
1398}
1399
1400int ocfs2_read_inode_block(struct inode *inode, struct buffer_head **bh)
1401{
1402 return ocfs2_read_inode_block_full(inode, bh, 0);
1403}
1404
1405
1406static u64 ocfs2_inode_cache_owner(struct ocfs2_caching_info *ci)
1407{
1408 struct ocfs2_inode_info *oi = cache_info_to_inode(ci);
1409
1410 return oi->ip_blkno;
1411}
1412
1413static struct super_block *ocfs2_inode_cache_get_super(struct ocfs2_caching_info *ci)
1414{
1415 struct ocfs2_inode_info *oi = cache_info_to_inode(ci);
1416
1417 return oi->vfs_inode.i_sb;
1418}
1419
1420static void ocfs2_inode_cache_lock(struct ocfs2_caching_info *ci)
1421{
1422 struct ocfs2_inode_info *oi = cache_info_to_inode(ci);
1423
1424 spin_lock(&oi->ip_lock);
1425}
1426
1427static void ocfs2_inode_cache_unlock(struct ocfs2_caching_info *ci)
1428{
1429 struct ocfs2_inode_info *oi = cache_info_to_inode(ci);
1430
1431 spin_unlock(&oi->ip_lock);
1432}
1433
1434static void ocfs2_inode_cache_io_lock(struct ocfs2_caching_info *ci)
1435{
1436 struct ocfs2_inode_info *oi = cache_info_to_inode(ci);
1437
1438 mutex_lock(&oi->ip_io_mutex);
1439}
1440
1441static void ocfs2_inode_cache_io_unlock(struct ocfs2_caching_info *ci)
1442{
1443 struct ocfs2_inode_info *oi = cache_info_to_inode(ci);
1444
1445 mutex_unlock(&oi->ip_io_mutex);
1446}
1447
1448const struct ocfs2_caching_operations ocfs2_inode_caching_ops = {
1449 .co_owner = ocfs2_inode_cache_owner,
1450 .co_get_super = ocfs2_inode_cache_get_super,
1451 .co_cache_lock = ocfs2_inode_cache_lock,
1452 .co_cache_unlock = ocfs2_inode_cache_unlock,
1453 .co_io_lock = ocfs2_inode_cache_io_lock,
1454 .co_io_unlock = ocfs2_inode_cache_io_unlock,
1455};
1456
1457