blob: 315472a5c1928de564a5e61514e41da69e674595 [file] [log] [blame]
Mark Fashehccd979b2005-12-15 14:31:24 -08001/* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * inode.c
5 *
6 * vfs' aops, fops, dops and iops
7 *
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the
22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 * Boston, MA 021110-1307, USA.
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/smp_lock.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 "dlmglue.h"
42#include "extent_map.h"
43#include "file.h"
Mark Fashehb4df6ed2006-02-22 17:35:08 -080044#include "heartbeat.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080045#include "inode.h"
46#include "journal.h"
47#include "namei.h"
48#include "suballoc.h"
49#include "super.h"
50#include "symlink.h"
51#include "sysfile.h"
52#include "uptodate.h"
53#include "vote.h"
54
55#include "buffer_head_io.h"
56
57#define OCFS2_FI_FLAG_NOWAIT 0x1
58#define OCFS2_FI_FLAG_DELETE 0x2
59struct ocfs2_find_inode_args
60{
61 u64 fi_blkno;
62 unsigned long fi_ino;
63 unsigned int fi_flags;
64};
65
66static int ocfs2_read_locked_inode(struct inode *inode,
67 struct ocfs2_find_inode_args *args);
68static int ocfs2_init_locked_inode(struct inode *inode, void *opaque);
69static int ocfs2_find_actor(struct inode *inode, void *opaque);
70static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
71 struct inode *inode,
72 struct buffer_head *fe_bh);
73
74struct inode *ocfs2_ilookup_for_vote(struct ocfs2_super *osb,
75 u64 blkno,
76 int delete_vote)
77{
78 struct ocfs2_find_inode_args args;
79
80 /* ocfs2_ilookup_for_vote should *only* be called from the
81 * vote thread */
82 BUG_ON(current != osb->vote_task);
83
84 args.fi_blkno = blkno;
85 args.fi_flags = OCFS2_FI_FLAG_NOWAIT;
86 if (delete_vote)
87 args.fi_flags |= OCFS2_FI_FLAG_DELETE;
88 args.fi_ino = ino_from_blkno(osb->sb, blkno);
89 return ilookup5(osb->sb, args.fi_ino, ocfs2_find_actor, &args);
90}
91
92struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno)
93{
94 struct inode *inode = NULL;
95 struct super_block *sb = osb->sb;
96 struct ocfs2_find_inode_args args;
97
98 mlog_entry("(blkno = %"MLFu64")\n", blkno);
99
100 /* Ok. By now we've either got the offsets passed to us by the
101 * caller, or we just pulled them off the bh. Lets do some
102 * sanity checks to make sure they're OK. */
103 if (blkno == 0) {
104 inode = ERR_PTR(-EINVAL);
105 mlog_errno(PTR_ERR(inode));
106 goto bail;
107 }
108
109 args.fi_blkno = blkno;
110 args.fi_flags = 0;
111 args.fi_ino = ino_from_blkno(sb, blkno);
112
113 inode = iget5_locked(sb, args.fi_ino, ocfs2_find_actor,
114 ocfs2_init_locked_inode, &args);
115 /* inode was *not* in the inode cache. 2.6.x requires
116 * us to do our own read_inode call and unlock it
117 * afterwards. */
118 if (inode && inode->i_state & I_NEW) {
119 mlog(0, "Inode was not in inode cache, reading it.\n");
120 ocfs2_read_locked_inode(inode, &args);
121 unlock_new_inode(inode);
122 }
123 if (inode == NULL) {
124 inode = ERR_PTR(-ENOMEM);
125 mlog_errno(PTR_ERR(inode));
126 goto bail;
127 }
128 if (is_bad_inode(inode)) {
129 iput(inode);
130 inode = ERR_PTR(-ESTALE);
131 mlog_errno(PTR_ERR(inode));
132 goto bail;
133 }
134
135bail:
136 if (!IS_ERR(inode)) {
137 mlog(0, "returning inode with number %"MLFu64"\n",
138 OCFS2_I(inode)->ip_blkno);
139 mlog_exit_ptr(inode);
140 } else
141 mlog_errno(PTR_ERR(inode));
142
143 return inode;
144}
145
146
147/*
148 * here's how inodes get read from disk:
149 * iget5_locked -> find_actor -> OCFS2_FIND_ACTOR
150 * found? : return the in-memory inode
151 * not found? : get_new_inode -> OCFS2_INIT_LOCKED_INODE
152 */
153
154static int ocfs2_find_actor(struct inode *inode, void *opaque)
155{
156 struct ocfs2_find_inode_args *args = NULL;
157 struct ocfs2_inode_info *oi = OCFS2_I(inode);
158 int ret = 0;
159
160 mlog_entry("(0x%p, %lu, 0x%p)\n", inode, inode->i_ino, opaque);
161
162 args = opaque;
163
164 mlog_bug_on_msg(!inode, "No inode in find actor!\n");
165
166 if (oi->ip_blkno != args->fi_blkno)
167 goto bail;
168
169 /* OCFS2_FI_FLAG_NOWAIT is *only* set from
170 * ocfs2_ilookup_for_vote which won't create an inode for one
171 * that isn't found. The vote thread which doesn't want to get
172 * an inode which is in the process of going away - otherwise
173 * the call to __wait_on_freeing_inode in find_inode_fast will
174 * cause it to deadlock on an inode which may be waiting on a
175 * vote (or lock release) in delete_inode */
176 if ((args->fi_flags & OCFS2_FI_FLAG_NOWAIT) &&
177 (inode->i_state & (I_FREEING|I_CLEAR))) {
178 /* As stated above, we're not going to return an
179 * inode. In the case of a delete vote, the voting
180 * code is going to signal the other node to go
181 * ahead. Mark that state here, so this freeing inode
182 * has the state when it gets to delete_inode. */
183 if (args->fi_flags & OCFS2_FI_FLAG_DELETE) {
184 spin_lock(&oi->ip_lock);
185 ocfs2_mark_inode_remotely_deleted(inode);
186 spin_unlock(&oi->ip_lock);
187 }
188 goto bail;
189 }
190
191 ret = 1;
192bail:
193 mlog_exit(ret);
194 return ret;
195}
196
197/*
198 * initialize the new inode, but don't do anything that would cause
199 * us to sleep.
200 * return 0 on success, 1 on failure
201 */
202static int ocfs2_init_locked_inode(struct inode *inode, void *opaque)
203{
204 struct ocfs2_find_inode_args *args = opaque;
205
206 mlog_entry("inode = %p, opaque = %p\n", inode, opaque);
207
208 inode->i_ino = args->fi_ino;
209 OCFS2_I(inode)->ip_blkno = args->fi_blkno;
210
211 mlog_exit(0);
212 return 0;
213}
214
215int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
216 int create_ino)
217{
218 struct super_block *sb;
219 struct ocfs2_super *osb;
220 int status = -EINVAL;
221
222 mlog_entry("(0x%p, size:%"MLFu64")\n", inode, fe->i_size);
223
224 sb = inode->i_sb;
225 osb = OCFS2_SB(sb);
226
227 /* this means that read_inode cannot create a superblock inode
228 * today. change if needed. */
229 if (!OCFS2_IS_VALID_DINODE(fe) ||
230 !(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL))) {
231 mlog(ML_ERROR, "Invalid dinode: i_ino=%lu, i_blkno=%"MLFu64", "
232 "signature = %.*s, flags = 0x%x\n",
233 inode->i_ino, le64_to_cpu(fe->i_blkno), 7,
234 fe->i_signature, le32_to_cpu(fe->i_flags));
235 goto bail;
236 }
237
238 if (le32_to_cpu(fe->i_fs_generation) != osb->fs_generation) {
239 mlog(ML_ERROR, "file entry generation does not match "
240 "superblock! osb->fs_generation=%x, "
241 "fe->i_fs_generation=%x\n",
242 osb->fs_generation, le32_to_cpu(fe->i_fs_generation));
243 goto bail;
244 }
245
246 inode->i_version = 1;
247 inode->i_generation = le32_to_cpu(fe->i_generation);
248 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
249 inode->i_mode = le16_to_cpu(fe->i_mode);
250 inode->i_uid = le32_to_cpu(fe->i_uid);
251 inode->i_gid = le32_to_cpu(fe->i_gid);
252 inode->i_blksize = (u32)osb->s_clustersize;
253
254 /* Fast symlinks will have i_size but no allocated clusters. */
255 if (S_ISLNK(inode->i_mode) && !fe->i_clusters)
256 inode->i_blocks = 0;
257 else
258 inode->i_blocks =
259 ocfs2_align_bytes_to_sectors(le64_to_cpu(fe->i_size));
260 inode->i_mapping->a_ops = &ocfs2_aops;
261 inode->i_flags |= S_NOATIME;
262 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
263 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
264 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
265 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
266 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
267 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
268
269 if (OCFS2_I(inode)->ip_blkno != le64_to_cpu(fe->i_blkno))
270 mlog(ML_ERROR,
271 "ip_blkno %"MLFu64" != i_blkno %"MLFu64"!\n",
272 OCFS2_I(inode)->ip_blkno, fe->i_blkno);
273
274 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
275 OCFS2_I(inode)->ip_orphaned_slot = OCFS2_INVALID_SLOT;
276
277 if (create_ino)
278 inode->i_ino = ino_from_blkno(inode->i_sb,
279 le64_to_cpu(fe->i_blkno));
280
281 mlog(0, "blkno = %"MLFu64", ino = %lu, create_ino = %s\n",
282 fe->i_blkno, inode->i_ino, create_ino ? "true" : "false");
283
284 inode->i_nlink = le16_to_cpu(fe->i_links_count);
285
286 if (fe->i_flags & cpu_to_le32(OCFS2_LOCAL_ALLOC_FL)) {
287 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
288 mlog(0, "local alloc inode: i_ino=%lu\n", inode->i_ino);
289 } else if (fe->i_flags & cpu_to_le32(OCFS2_BITMAP_FL)) {
290 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
291 } else if (fe->i_flags & cpu_to_le32(OCFS2_SUPER_BLOCK_FL)) {
292 mlog(0, "superblock inode: i_ino=%lu\n", inode->i_ino);
293 /* we can't actually hit this as read_inode can't
294 * handle superblocks today ;-) */
295 BUG();
296 }
297
298 switch (inode->i_mode & S_IFMT) {
299 case S_IFREG:
300 inode->i_fop = &ocfs2_fops;
301 inode->i_op = &ocfs2_file_iops;
302 i_size_write(inode, le64_to_cpu(fe->i_size));
303 break;
304 case S_IFDIR:
305 inode->i_op = &ocfs2_dir_iops;
306 inode->i_fop = &ocfs2_dops;
307 i_size_write(inode, le64_to_cpu(fe->i_size));
308 break;
309 case S_IFLNK:
310 if (ocfs2_inode_is_fast_symlink(inode))
311 inode->i_op = &ocfs2_fast_symlink_inode_operations;
312 else
313 inode->i_op = &ocfs2_symlink_inode_operations;
314 i_size_write(inode, le64_to_cpu(fe->i_size));
315 break;
316 default:
317 inode->i_op = &ocfs2_special_file_iops;
318 init_special_inode(inode, inode->i_mode,
319 inode->i_rdev);
320 break;
321 }
322
323 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_rw_lockres,
324 OCFS2_LOCK_TYPE_RW, inode);
325 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_meta_lockres,
326 OCFS2_LOCK_TYPE_META, inode);
327 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_data_lockres,
328 OCFS2_LOCK_TYPE_DATA, inode);
329
330 status = 0;
331bail:
332 mlog_exit(status);
333 return status;
334}
335
336static int ocfs2_read_locked_inode(struct inode *inode,
337 struct ocfs2_find_inode_args *args)
338{
339 struct super_block *sb;
340 struct ocfs2_super *osb;
341 struct ocfs2_dinode *fe;
342 struct buffer_head *bh = NULL;
343 int status;
344 int sysfile = 0;
345
346 mlog_entry("(0x%p, 0x%p)\n", inode, args);
347
348 status = -EINVAL;
349 if (inode == NULL || inode->i_sb == NULL) {
350 mlog(ML_ERROR, "bad inode\n");
351 goto bail;
352 }
353 sb = inode->i_sb;
354 osb = OCFS2_SB(sb);
355
356 if (!args) {
357 mlog(ML_ERROR, "bad inode args\n");
358 make_bad_inode(inode);
359 goto bail;
360 }
361
362 /* Read the FE off disk. This is safe because the kernel only
363 * does one read_inode2 for a new inode, and if it doesn't
364 * exist yet then nobody can be working on it! */
365 status = ocfs2_read_block(osb, args->fi_blkno, &bh, 0, NULL);
366 if (status < 0) {
367 mlog_errno(status);
368 make_bad_inode(inode);
369 goto bail;
370 }
371
372 fe = (struct ocfs2_dinode *) bh->b_data;
373 if (!OCFS2_IS_VALID_DINODE(fe)) {
374 mlog(ML_ERROR, "Invalid dinode #%"MLFu64": signature = %.*s\n",
375 fe->i_blkno, 7, fe->i_signature);
376 make_bad_inode(inode);
377 goto bail;
378 }
379
380 if (fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL))
381 sysfile = 1;
382
383 if (S_ISCHR(le16_to_cpu(fe->i_mode)) ||
384 S_ISBLK(le16_to_cpu(fe->i_mode)))
385 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
386
387 status = -EINVAL;
388 if (ocfs2_populate_inode(inode, fe, 0) < 0) {
389 mlog(ML_ERROR, "populate inode failed! i_blkno=%"MLFu64", "
390 "i_ino=%lu\n", fe->i_blkno, inode->i_ino);
391 make_bad_inode(inode);
392 goto bail;
393 }
394
395 BUG_ON(args->fi_blkno != le64_to_cpu(fe->i_blkno));
396
397 if (sysfile)
398 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SYSTEM_FILE;
399
400 status = 0;
401
402bail:
403 if (args && bh)
404 brelse(bh);
405
406 mlog_exit(status);
407 return status;
408}
409
410void ocfs2_sync_blockdev(struct super_block *sb)
411{
412 sync_blockdev(sb->s_bdev);
413}
414
415static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
416 struct inode *inode,
417 struct buffer_head *fe_bh)
418{
419 int status = 0;
420 struct ocfs2_journal_handle *handle = NULL;
421 struct ocfs2_truncate_context *tc = NULL;
422 struct ocfs2_dinode *fe;
423
424 mlog_entry_void();
425
426 fe = (struct ocfs2_dinode *) fe_bh->b_data;
427
428 /* zero allocation, zero truncate :) */
429 if (!fe->i_clusters)
430 goto bail;
431
432 handle = ocfs2_start_trans(osb, handle, OCFS2_INODE_UPDATE_CREDITS);
433 if (IS_ERR(handle)) {
434 status = PTR_ERR(handle);
435 handle = NULL;
436 mlog_errno(status);
437 goto bail;
438 }
439
440 status = ocfs2_set_inode_size(handle, inode, fe_bh, 0ULL);
441 if (status < 0) {
442 mlog_errno(status);
443 goto bail;
444 }
445
446 ocfs2_commit_trans(handle);
447 handle = NULL;
448
449 status = ocfs2_prepare_truncate(osb, inode, fe_bh, &tc);
450 if (status < 0) {
451 mlog_errno(status);
452 goto bail;
453 }
454
455 status = ocfs2_commit_truncate(osb, inode, fe_bh, tc);
456 if (status < 0) {
457 mlog_errno(status);
458 goto bail;
459 }
460bail:
461 if (handle)
462 ocfs2_commit_trans(handle);
463
464 mlog_exit(status);
465 return status;
466}
467
468static int ocfs2_remove_inode(struct inode *inode,
469 struct buffer_head *di_bh,
470 struct inode *orphan_dir_inode,
471 struct buffer_head *orphan_dir_bh)
472{
473 int status;
474 struct inode *inode_alloc_inode = NULL;
475 struct buffer_head *inode_alloc_bh = NULL;
476 struct ocfs2_journal_handle *handle;
477 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
478 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
479
480 inode_alloc_inode =
481 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE,
482 le16_to_cpu(di->i_suballoc_slot));
483 if (!inode_alloc_inode) {
484 status = -EEXIST;
485 mlog_errno(status);
486 goto bail;
487 }
488
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800489 mutex_lock(&inode_alloc_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800490 status = ocfs2_meta_lock(inode_alloc_inode, NULL, &inode_alloc_bh, 1);
491 if (status < 0) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800492 mutex_unlock(&inode_alloc_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800493
494 mlog_errno(status);
495 goto bail;
496 }
497
498 handle = ocfs2_start_trans(osb, NULL, OCFS2_DELETE_INODE_CREDITS);
499 if (IS_ERR(handle)) {
500 status = PTR_ERR(handle);
501 mlog_errno(status);
502 goto bail_unlock;
503 }
504
505 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
506 orphan_dir_bh);
507 if (status < 0) {
508 mlog_errno(status);
509 goto bail_commit;
510 }
511
512 /* set the inodes dtime */
513 status = ocfs2_journal_access(handle, inode, di_bh,
514 OCFS2_JOURNAL_ACCESS_WRITE);
515 if (status < 0) {
516 mlog_errno(status);
517 goto bail_commit;
518 }
519
520 di->i_dtime = cpu_to_le64(CURRENT_TIME.tv_sec);
521 le32_and_cpu(&di->i_flags, ~(OCFS2_VALID_FL | OCFS2_ORPHANED_FL));
522
523 status = ocfs2_journal_dirty(handle, di_bh);
524 if (status < 0) {
525 mlog_errno(status);
526 goto bail_commit;
527 }
528
529 ocfs2_remove_from_cache(inode, di_bh);
530
531 status = ocfs2_free_dinode(handle, inode_alloc_inode,
532 inode_alloc_bh, di);
533 if (status < 0)
534 mlog_errno(status);
535
536bail_commit:
537 ocfs2_commit_trans(handle);
538bail_unlock:
539 ocfs2_meta_unlock(inode_alloc_inode, 1);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800540 mutex_unlock(&inode_alloc_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800541 brelse(inode_alloc_bh);
542bail:
543 iput(inode_alloc_inode);
544
545 return status;
546}
547
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800548/*
549 * Serialize with orphan dir recovery. If the process doing
550 * recovery on this orphan dir does an iget() with the dir
551 * i_mutex held, we'll deadlock here. Instead we detect this
552 * and exit early - recovery will wipe this inode for us.
553 */
554static int ocfs2_check_orphan_recovery_state(struct ocfs2_super *osb,
555 int slot)
556{
557 int ret = 0;
558
559 spin_lock(&osb->osb_lock);
560 if (ocfs2_node_map_test_bit(osb, &osb->osb_recovering_orphan_dirs, slot)) {
561 mlog(0, "Recovery is happening on orphan dir %d, will skip "
562 "this inode\n", slot);
563 ret = -EDEADLK;
564 goto out;
565 }
566 /* This signals to the orphan recovery process that it should
567 * wait for us to handle the wipe. */
568 osb->osb_orphan_wipes[slot]++;
569out:
570 spin_unlock(&osb->osb_lock);
571 return ret;
572}
573
574static void ocfs2_signal_wipe_completion(struct ocfs2_super *osb,
575 int slot)
576{
577 spin_lock(&osb->osb_lock);
578 osb->osb_orphan_wipes[slot]--;
579 spin_unlock(&osb->osb_lock);
580
581 wake_up(&osb->osb_wipe_event);
582}
583
Mark Fashehccd979b2005-12-15 14:31:24 -0800584static int ocfs2_wipe_inode(struct inode *inode,
585 struct buffer_head *di_bh)
586{
587 int status, orphaned_slot;
588 struct inode *orphan_dir_inode = NULL;
589 struct buffer_head *orphan_dir_bh = NULL;
590 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
591
592 /* We've already voted on this so it should be readonly - no
593 * spinlock needed. */
594 orphaned_slot = OCFS2_I(inode)->ip_orphaned_slot;
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800595
596 status = ocfs2_check_orphan_recovery_state(osb, orphaned_slot);
597 if (status)
598 return status;
599
Mark Fashehccd979b2005-12-15 14:31:24 -0800600 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
601 ORPHAN_DIR_SYSTEM_INODE,
602 orphaned_slot);
603 if (!orphan_dir_inode) {
604 status = -EEXIST;
605 mlog_errno(status);
606 goto bail;
607 }
608
609 /* Lock the orphan dir. The lock will be held for the entire
610 * delete_inode operation. We do this now to avoid races with
611 * recovery completion on other nodes. */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800612 mutex_lock(&orphan_dir_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800613 status = ocfs2_meta_lock(orphan_dir_inode, NULL, &orphan_dir_bh, 1);
614 if (status < 0) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800615 mutex_unlock(&orphan_dir_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800616
617 mlog_errno(status);
618 goto bail;
619 }
620
621 /* we do this while holding the orphan dir lock because we
622 * don't want recovery being run from another node to vote for
623 * an inode delete on us -- this will result in two nodes
624 * truncating the same file! */
625 status = ocfs2_truncate_for_delete(osb, inode, di_bh);
626 if (status < 0) {
627 mlog_errno(status);
628 goto bail_unlock_dir;
629 }
630
631 status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode,
632 orphan_dir_bh);
633 if (status < 0)
634 mlog_errno(status);
635
636bail_unlock_dir:
637 ocfs2_meta_unlock(orphan_dir_inode, 1);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800638 mutex_unlock(&orphan_dir_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800639 brelse(orphan_dir_bh);
640bail:
641 iput(orphan_dir_inode);
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800642 ocfs2_signal_wipe_completion(osb, orphaned_slot);
Mark Fashehccd979b2005-12-15 14:31:24 -0800643
644 return status;
645}
646
647/* There is a series of simple checks that should be done before a
648 * vote is even considered. Encapsulate those in this function. */
649static int ocfs2_inode_is_valid_to_delete(struct inode *inode)
650{
651 int ret = 0;
652 struct ocfs2_inode_info *oi = OCFS2_I(inode);
653 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
654
655 /* We shouldn't be getting here for the root directory
656 * inode.. */
657 if (inode == osb->root_inode) {
658 mlog(ML_ERROR, "Skipping delete of root inode.\n");
659 goto bail;
660 }
661
662 /* If we're coming from process_vote we can't go into our own
663 * voting [hello, deadlock city!], so unforuntately we just
664 * have to skip deleting this guy. That's OK though because
665 * the node who's doing the actual deleting should handle it
666 * anyway. */
667 if (current == osb->vote_task) {
668 mlog(0, "Skipping delete of %lu because we're currently "
669 "in process_vote\n", inode->i_ino);
670 goto bail;
671 }
672
673 spin_lock(&oi->ip_lock);
674 /* OCFS2 *never* deletes system files. This should technically
675 * never get here as system file inodes should always have a
676 * positive link count. */
677 if (oi->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
678 mlog(ML_ERROR, "Skipping delete of system file %"MLFu64".\n",
679 oi->ip_blkno);
680 goto bail_unlock;
681 }
682
683 /* If we have voted "yes" on the wipe of this inode for
684 * another node, it will be marked here so we can safely skip
685 * it. Recovery will cleanup any inodes we might inadvertantly
686 * skip here. */
687 if (oi->ip_flags & OCFS2_INODE_SKIP_DELETE) {
688 mlog(0, "Skipping delete of %lu because another node "
689 "has done this for us.\n", inode->i_ino);
690 goto bail_unlock;
691 }
692
693 ret = 1;
694bail_unlock:
695 spin_unlock(&oi->ip_lock);
696bail:
697 return ret;
698}
699
700/* Query the cluster to determine whether we should wipe an inode from
701 * disk or not.
702 *
703 * Requires the inode to have the cluster lock. */
704static int ocfs2_query_inode_wipe(struct inode *inode,
705 struct buffer_head *di_bh,
706 int *wipe)
707{
708 int status = 0;
709 struct ocfs2_inode_info *oi = OCFS2_I(inode);
710 struct ocfs2_dinode *di;
711
712 *wipe = 0;
713
714 /* While we were waiting for the cluster lock in
715 * ocfs2_delete_inode, another node might have asked to delete
716 * the inode. Recheck our flags to catch this. */
717 if (!ocfs2_inode_is_valid_to_delete(inode)) {
718 mlog(0, "Skipping delete of %"MLFu64" because flags changed\n",
719 oi->ip_blkno);
720 goto bail;
721 }
722
723 /* Now that we have an up to date inode, we can double check
724 * the link count. */
725 if (inode->i_nlink) {
726 mlog(0, "Skipping delete of %"MLFu64" because nlink = %u\n",
727 oi->ip_blkno, inode->i_nlink);
728 goto bail;
729 }
730
731 /* Do some basic inode verification... */
732 di = (struct ocfs2_dinode *) di_bh->b_data;
733 if (!(di->i_flags & cpu_to_le32(OCFS2_ORPHANED_FL))) {
734 /* for lack of a better error? */
735 status = -EEXIST;
736 mlog(ML_ERROR,
737 "Inode %"MLFu64" (on-disk %"MLFu64") not orphaned! "
738 "Disk flags 0x%x, inode flags 0x%x\n",
739 oi->ip_blkno, di->i_blkno, di->i_flags, oi->ip_flags);
740 goto bail;
741 }
742
743 /* has someone already deleted us?! baaad... */
744 if (di->i_dtime) {
745 status = -EEXIST;
746 mlog_errno(status);
747 goto bail;
748 }
749
750 status = ocfs2_request_delete_vote(inode);
751 /* -EBUSY means that other nodes are still using the
752 * inode. We're done here though, so avoid doing anything on
753 * disk and let them worry about deleting it. */
754 if (status == -EBUSY) {
755 status = 0;
756 mlog(0, "Skipping delete of %"MLFu64" because it is in use on"
757 "other nodes\n", oi->ip_blkno);
758 goto bail;
759 }
760 if (status < 0) {
761 mlog_errno(status);
762 goto bail;
763 }
764
765 spin_lock(&oi->ip_lock);
766 if (oi->ip_orphaned_slot == OCFS2_INVALID_SLOT) {
767 /* Nobody knew which slot this inode was orphaned
768 * into. This may happen during node death and
769 * recovery knows how to clean it up so we can safely
770 * ignore this inode for now on. */
771 mlog(0, "Nobody knew where inode %"MLFu64" was orphaned!\n",
772 oi->ip_blkno);
773 } else {
774 *wipe = 1;
775
776 mlog(0, "Inode %"MLFu64" is ok to wipe from orphan dir %d\n",
777 oi->ip_blkno, oi->ip_orphaned_slot);
778 }
779 spin_unlock(&oi->ip_lock);
780
781bail:
782 return status;
783}
784
785/* Support function for ocfs2_delete_inode. Will help us keep the
786 * inode data in a consistent state for clear_inode. Always truncates
787 * pages, optionally sync's them first. */
788static void ocfs2_cleanup_delete_inode(struct inode *inode,
789 int sync_data)
790{
791 mlog(0, "Cleanup inode %"MLFu64", sync = %d\n",
792 OCFS2_I(inode)->ip_blkno, sync_data);
793 if (sync_data)
794 write_inode_now(inode, 1);
795 truncate_inode_pages(&inode->i_data, 0);
796}
797
798void ocfs2_delete_inode(struct inode *inode)
799{
800 int wipe, status;
801 sigset_t blocked, oldset;
802 struct buffer_head *di_bh = NULL;
803
804 mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
805
806 if (is_bad_inode(inode)) {
807 mlog(0, "Skipping delete of bad inode\n");
808 goto bail;
809 }
810
811 if (!ocfs2_inode_is_valid_to_delete(inode)) {
812 /* It's probably not necessary to truncate_inode_pages
813 * here but we do it for safety anyway (it will most
814 * likely be a no-op anyway) */
815 ocfs2_cleanup_delete_inode(inode, 0);
816 goto bail;
817 }
818
819 /* We want to block signals in delete_inode as the lock and
820 * messaging paths may return us -ERESTARTSYS. Which would
821 * cause us to exit early, resulting in inodes being orphaned
822 * forever. */
823 sigfillset(&blocked);
824 status = sigprocmask(SIG_BLOCK, &blocked, &oldset);
825 if (status < 0) {
826 mlog_errno(status);
827 ocfs2_cleanup_delete_inode(inode, 1);
828 goto bail;
829 }
830
831 /* Lock down the inode. This gives us an up to date view of
832 * it's metadata (for verification), and allows us to
833 * serialize delete_inode votes.
834 *
835 * Even though we might be doing a truncate, we don't take the
836 * allocation lock here as it won't be needed - nobody will
837 * have the file open.
838 */
839 status = ocfs2_meta_lock(inode, NULL, &di_bh, 1);
840 if (status < 0) {
841 if (status != -ENOENT)
842 mlog_errno(status);
843 ocfs2_cleanup_delete_inode(inode, 0);
844 goto bail_unblock;
845 }
846
847 /* Query the cluster. This will be the final decision made
848 * before we go ahead and wipe the inode. */
849 status = ocfs2_query_inode_wipe(inode, di_bh, &wipe);
850 if (!wipe || status < 0) {
851 /* Error and inode busy vote both mean we won't be
852 * removing the inode, so they take almost the same
853 * path. */
854 if (status < 0)
855 mlog_errno(status);
856
857 /* Someone in the cluster has voted to not wipe this
858 * inode, or it was never completely orphaned. Write
859 * out the pages and exit now. */
860 ocfs2_cleanup_delete_inode(inode, 1);
861 goto bail_unlock_inode;
862 }
863
864 ocfs2_cleanup_delete_inode(inode, 0);
865
866 status = ocfs2_wipe_inode(inode, di_bh);
867 if (status < 0) {
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800868 if (status != -EDEADLK)
869 mlog_errno(status);
Mark Fashehccd979b2005-12-15 14:31:24 -0800870 goto bail_unlock_inode;
871 }
872
873 /* Mark the inode as successfully deleted. This is important
874 * for ocfs2_clear_inode as it will check this flag and skip
875 * any checkpointing work */
876 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_DELETED;
877
878bail_unlock_inode:
879 ocfs2_meta_unlock(inode, 1);
880 brelse(di_bh);
881bail_unblock:
882 status = sigprocmask(SIG_SETMASK, &oldset, NULL);
883 if (status < 0)
884 mlog_errno(status);
885bail:
886 clear_inode(inode);
887 mlog_exit_void();
888}
889
890void ocfs2_clear_inode(struct inode *inode)
891{
892 int status;
893 struct ocfs2_inode_info *oi = OCFS2_I(inode);
894
895 mlog_entry_void();
896
897 if (!inode)
898 goto bail;
899
900 mlog(0, "Clearing inode: %"MLFu64", nlink = %u\n",
901 OCFS2_I(inode)->ip_blkno, inode->i_nlink);
902
903 mlog_bug_on_msg(OCFS2_SB(inode->i_sb) == NULL,
904 "Inode=%lu\n", inode->i_ino);
905
906 /* Do these before all the other work so that we don't bounce
907 * the vote thread while waiting to destroy the locks. */
908 ocfs2_mark_lockres_freeing(&oi->ip_rw_lockres);
909 ocfs2_mark_lockres_freeing(&oi->ip_meta_lockres);
910 ocfs2_mark_lockres_freeing(&oi->ip_data_lockres);
911
912 /* We very well may get a clear_inode before all an inodes
913 * metadata has hit disk. Of course, we can't drop any cluster
914 * locks until the journal has finished with it. The only
915 * exception here are successfully wiped inodes - their
916 * metadata can now be considered to be part of the system
917 * inodes from which it came. */
918 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED))
919 ocfs2_checkpoint_inode(inode);
920
921 mlog_bug_on_msg(!list_empty(&oi->ip_io_markers),
922 "Clear inode of %"MLFu64", inode has io markers\n",
923 oi->ip_blkno);
924
925 ocfs2_extent_map_drop(inode, 0);
926 ocfs2_extent_map_init(inode);
927
928 status = ocfs2_drop_inode_locks(inode);
929 if (status < 0)
930 mlog_errno(status);
931
932 ocfs2_lock_res_free(&oi->ip_rw_lockres);
933 ocfs2_lock_res_free(&oi->ip_meta_lockres);
934 ocfs2_lock_res_free(&oi->ip_data_lockres);
935
936 ocfs2_metadata_cache_purge(inode);
937
938 mlog_bug_on_msg(oi->ip_metadata_cache.ci_num_cached,
939 "Clear inode of %"MLFu64", inode has %u cache items\n",
940 oi->ip_blkno, oi->ip_metadata_cache.ci_num_cached);
941
942 mlog_bug_on_msg(!(oi->ip_flags & OCFS2_INODE_CACHE_INLINE),
943 "Clear inode of %"MLFu64", inode has a bad flag\n",
944 oi->ip_blkno);
945
946 mlog_bug_on_msg(spin_is_locked(&oi->ip_lock),
947 "Clear inode of %"MLFu64", inode is locked\n",
948 oi->ip_blkno);
949
Mark Fasheh251b6ec2006-01-10 15:41:43 -0800950 mlog_bug_on_msg(!mutex_trylock(&oi->ip_io_mutex),
951 "Clear inode of %"MLFu64", io_mutex is locked\n",
Mark Fashehccd979b2005-12-15 14:31:24 -0800952 oi->ip_blkno);
Mark Fasheh251b6ec2006-01-10 15:41:43 -0800953 mutex_unlock(&oi->ip_io_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800954
955 /*
956 * down_trylock() returns 0, down_write_trylock() returns 1
957 * kernel 1, world 0
958 */
959 mlog_bug_on_msg(!down_write_trylock(&oi->ip_alloc_sem),
960 "Clear inode of %"MLFu64", alloc_sem is locked\n",
961 oi->ip_blkno);
962 up_write(&oi->ip_alloc_sem);
963
964 mlog_bug_on_msg(oi->ip_open_count,
965 "Clear inode of %"MLFu64" has open count %d\n",
966 oi->ip_blkno, oi->ip_open_count);
967 mlog_bug_on_msg(!list_empty(&oi->ip_handle_list),
968 "Clear inode of %"MLFu64" has non empty handle list\n",
969 oi->ip_blkno);
970 mlog_bug_on_msg(oi->ip_handle,
971 "Clear inode of %"MLFu64" has non empty handle pointer\n",
972 oi->ip_blkno);
973
974 /* Clear all other flags. */
975 oi->ip_flags = OCFS2_INODE_CACHE_INLINE;
976 oi->ip_created_trans = 0;
977 oi->ip_last_trans = 0;
978 oi->ip_dir_start_lookup = 0;
979 oi->ip_blkno = 0ULL;
980
981bail:
982 mlog_exit_void();
983}
984
985/* Called under inode_lock, with no more references on the
986 * struct inode, so it's safe here to check the flags field
987 * and to manipulate i_nlink without any other locks. */
988void ocfs2_drop_inode(struct inode *inode)
989{
990 struct ocfs2_inode_info *oi = OCFS2_I(inode);
991
992 mlog_entry_void();
993
994 mlog(0, "Drop inode %"MLFu64", nlink = %u, ip_flags = 0x%x\n",
995 oi->ip_blkno, inode->i_nlink, oi->ip_flags);
996
997 /* Testing ip_orphaned_slot here wouldn't work because we may
998 * not have gotten a delete_inode vote from any other nodes
999 * yet. */
1000 if (oi->ip_flags & OCFS2_INODE_MAYBE_ORPHANED) {
1001 mlog(0, "Inode was orphaned on another node, clearing nlink.\n");
1002 inode->i_nlink = 0;
1003 }
1004
1005 generic_drop_inode(inode);
1006
1007 mlog_exit_void();
1008}
1009
1010/*
1011 * TODO: this should probably be merged into ocfs2_get_block
1012 *
1013 * However, you now need to pay attention to the cont_prepare_write()
1014 * stuff in ocfs2_get_block (that is, ocfs2_get_block pretty much
1015 * expects never to extend).
1016 */
1017struct buffer_head *ocfs2_bread(struct inode *inode,
1018 int block, int *err, int reada)
1019{
1020 struct buffer_head *bh = NULL;
1021 int tmperr;
1022 u64 p_blkno;
1023 int readflags = OCFS2_BH_CACHED;
1024
1025#if 0
1026 /* only turn this on if we know we can deal with read_block
1027 * returning nothing */
1028 if (reada)
1029 readflags |= OCFS2_BH_READAHEAD;
1030#endif
1031
1032 if (((u64)block << inode->i_sb->s_blocksize_bits) >=
1033 i_size_read(inode)) {
1034 BUG_ON(!reada);
1035 return NULL;
1036 }
1037
1038 tmperr = ocfs2_extent_map_get_blocks(inode, block, 1,
1039 &p_blkno, NULL);
1040 if (tmperr < 0) {
1041 mlog_errno(tmperr);
1042 goto fail;
1043 }
1044
1045 tmperr = ocfs2_read_block(OCFS2_SB(inode->i_sb), p_blkno, &bh,
1046 readflags, inode);
1047 if (tmperr < 0)
1048 goto fail;
1049
1050 tmperr = 0;
1051
1052 *err = 0;
1053 return bh;
1054
1055fail:
1056 if (bh) {
1057 brelse(bh);
1058 bh = NULL;
1059 }
1060 *err = -EIO;
1061 return NULL;
1062}
1063
1064/*
1065 * This is called from our getattr.
1066 */
1067int ocfs2_inode_revalidate(struct dentry *dentry)
1068{
1069 struct inode *inode = dentry->d_inode;
1070 int status = 0;
1071
1072 mlog_entry("(inode = 0x%p, ino = %"MLFu64")\n", inode,
1073 inode ? OCFS2_I(inode)->ip_blkno : 0ULL);
1074
1075 if (!inode) {
1076 mlog(0, "eep, no inode!\n");
1077 status = -ENOENT;
1078 goto bail;
1079 }
1080
1081 spin_lock(&OCFS2_I(inode)->ip_lock);
1082 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
1083 spin_unlock(&OCFS2_I(inode)->ip_lock);
1084 mlog(0, "inode deleted!\n");
1085 status = -ENOENT;
1086 goto bail;
1087 }
1088 spin_unlock(&OCFS2_I(inode)->ip_lock);
1089
1090 /* Let ocfs2_meta_lock do the work of updating our struct
1091 * inode for us. */
1092 status = ocfs2_meta_lock(inode, NULL, NULL, 0);
1093 if (status < 0) {
1094 if (status != -ENOENT)
1095 mlog_errno(status);
1096 goto bail;
1097 }
1098 ocfs2_meta_unlock(inode, 0);
1099bail:
1100 mlog_exit(status);
1101
1102 return status;
1103}
1104
1105/*
1106 * Updates a disk inode from a
1107 * struct inode.
1108 * Only takes ip_lock.
1109 */
1110int ocfs2_mark_inode_dirty(struct ocfs2_journal_handle *handle,
1111 struct inode *inode,
1112 struct buffer_head *bh)
1113{
1114 int status;
1115 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
1116
1117 mlog_entry("(inode %"MLFu64")\n", OCFS2_I(inode)->ip_blkno);
1118
1119 status = ocfs2_journal_access(handle, inode, bh,
1120 OCFS2_JOURNAL_ACCESS_WRITE);
1121 if (status < 0) {
1122 mlog_errno(status);
1123 goto leave;
1124 }
1125
1126 spin_lock(&OCFS2_I(inode)->ip_lock);
1127 fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
1128 spin_unlock(&OCFS2_I(inode)->ip_lock);
1129
1130 fe->i_size = cpu_to_le64(i_size_read(inode));
1131 fe->i_links_count = cpu_to_le16(inode->i_nlink);
1132 fe->i_uid = cpu_to_le32(inode->i_uid);
1133 fe->i_gid = cpu_to_le32(inode->i_gid);
1134 fe->i_mode = cpu_to_le16(inode->i_mode);
1135 fe->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
1136 fe->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
1137 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
1138 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
1139 fe->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
1140 fe->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
1141
1142 status = ocfs2_journal_dirty(handle, bh);
1143 if (status < 0)
1144 mlog_errno(status);
1145
1146 status = 0;
1147leave:
1148
1149 mlog_exit(status);
1150 return status;
1151}
1152
1153/*
1154 *
1155 * Updates a struct inode from a disk inode.
1156 * does no i/o, only takes ip_lock.
1157 */
1158void ocfs2_refresh_inode(struct inode *inode,
1159 struct ocfs2_dinode *fe)
1160{
1161 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1162
1163 spin_lock(&OCFS2_I(inode)->ip_lock);
1164
1165 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
1166 i_size_write(inode, le64_to_cpu(fe->i_size));
1167 inode->i_nlink = le16_to_cpu(fe->i_links_count);
1168 inode->i_uid = le32_to_cpu(fe->i_uid);
1169 inode->i_gid = le32_to_cpu(fe->i_gid);
1170 inode->i_mode = le16_to_cpu(fe->i_mode);
1171 inode->i_blksize = (u32) osb->s_clustersize;
1172 if (S_ISLNK(inode->i_mode) && le32_to_cpu(fe->i_clusters) == 0)
1173 inode->i_blocks = 0;
1174 else
1175 inode->i_blocks = ocfs2_align_bytes_to_sectors(i_size_read(inode));
1176 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
1177 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
1178 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
1179 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
1180 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
1181 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
1182
1183 spin_unlock(&OCFS2_I(inode)->ip_lock);
1184}