blob: 7e9e4c79aec7bf4b3e4488190f47972821a3945f [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>
Mark Fashehccd979b2005-12-15 14:31:24 -080031
32#include <asm/byteorder.h>
33
34#define MLOG_MASK_PREFIX ML_INODE
35#include <cluster/masklog.h>
36
37#include "ocfs2.h"
38
39#include "alloc.h"
40#include "dlmglue.h"
41#include "extent_map.h"
42#include "file.h"
Mark Fashehb4df6ed2006-02-22 17:35:08 -080043#include "heartbeat.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080044#include "inode.h"
45#include "journal.h"
46#include "namei.h"
47#include "suballoc.h"
48#include "super.h"
49#include "symlink.h"
50#include "sysfile.h"
51#include "uptodate.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080052
53#include "buffer_head_io.h"
54
Mark Fashehccd979b2005-12-15 14:31:24 -080055struct ocfs2_find_inode_args
56{
57 u64 fi_blkno;
58 unsigned long fi_ino;
59 unsigned int fi_flags;
Jan Kara5fa06132008-01-11 00:11:45 +010060 unsigned int fi_sysfile_type;
Mark Fashehccd979b2005-12-15 14:31:24 -080061};
62
Jan Kara5fa06132008-01-11 00:11:45 +010063static struct lock_class_key ocfs2_sysfile_lock_key[NUM_SYSTEM_INODES];
64
Mark Fashehccd979b2005-12-15 14:31:24 -080065static int ocfs2_read_locked_inode(struct inode *inode,
66 struct ocfs2_find_inode_args *args);
67static int ocfs2_init_locked_inode(struct inode *inode, void *opaque);
68static int ocfs2_find_actor(struct inode *inode, void *opaque);
69static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
70 struct inode *inode,
71 struct buffer_head *fe_bh);
72
Herbert Poetzlca4d1472006-07-03 17:27:12 -070073void ocfs2_set_inode_flags(struct inode *inode)
74{
75 unsigned int flags = OCFS2_I(inode)->ip_attr;
76
77 inode->i_flags &= ~(S_IMMUTABLE |
78 S_SYNC | S_APPEND | S_NOATIME | S_DIRSYNC);
79
80 if (flags & OCFS2_IMMUTABLE_FL)
81 inode->i_flags |= S_IMMUTABLE;
82
83 if (flags & OCFS2_SYNC_FL)
84 inode->i_flags |= S_SYNC;
85 if (flags & OCFS2_APPEND_FL)
86 inode->i_flags |= S_APPEND;
87 if (flags & OCFS2_NOATIME_FL)
88 inode->i_flags |= S_NOATIME;
89 if (flags & OCFS2_DIRSYNC_FL)
90 inode->i_flags |= S_DIRSYNC;
91}
92
Jan Kara6e4b0d52007-04-27 11:08:01 -070093/* Propagate flags from i_flags to OCFS2_I(inode)->ip_attr */
94void ocfs2_get_inode_flags(struct ocfs2_inode_info *oi)
95{
96 unsigned int flags = oi->vfs_inode.i_flags;
97
98 oi->ip_attr &= ~(OCFS2_SYNC_FL|OCFS2_APPEND_FL|
99 OCFS2_IMMUTABLE_FL|OCFS2_NOATIME_FL|OCFS2_DIRSYNC_FL);
100 if (flags & S_SYNC)
101 oi->ip_attr |= OCFS2_SYNC_FL;
102 if (flags & S_APPEND)
103 oi->ip_attr |= OCFS2_APPEND_FL;
104 if (flags & S_IMMUTABLE)
105 oi->ip_attr |= OCFS2_IMMUTABLE_FL;
106 if (flags & S_NOATIME)
107 oi->ip_attr |= OCFS2_NOATIME_FL;
108 if (flags & S_DIRSYNC)
109 oi->ip_attr |= OCFS2_DIRSYNC_FL;
110}
111
Jan Kara5fa06132008-01-11 00:11:45 +0100112struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, unsigned flags,
113 int sysfile_type)
Mark Fashehccd979b2005-12-15 14:31:24 -0800114{
115 struct inode *inode = NULL;
116 struct super_block *sb = osb->sb;
117 struct ocfs2_find_inode_args args;
118
Mark Fashehb06970532006-03-03 10:24:33 -0800119 mlog_entry("(blkno = %llu)\n", (unsigned long long)blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800120
121 /* Ok. By now we've either got the offsets passed to us by the
122 * caller, or we just pulled them off the bh. Lets do some
123 * sanity checks to make sure they're OK. */
124 if (blkno == 0) {
125 inode = ERR_PTR(-EINVAL);
126 mlog_errno(PTR_ERR(inode));
127 goto bail;
128 }
129
130 args.fi_blkno = blkno;
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700131 args.fi_flags = flags;
Mark Fashehccd979b2005-12-15 14:31:24 -0800132 args.fi_ino = ino_from_blkno(sb, blkno);
Jan Kara5fa06132008-01-11 00:11:45 +0100133 args.fi_sysfile_type = sysfile_type;
Mark Fashehccd979b2005-12-15 14:31:24 -0800134
135 inode = iget5_locked(sb, args.fi_ino, ocfs2_find_actor,
136 ocfs2_init_locked_inode, &args);
137 /* inode was *not* in the inode cache. 2.6.x requires
138 * us to do our own read_inode call and unlock it
139 * afterwards. */
140 if (inode && inode->i_state & I_NEW) {
141 mlog(0, "Inode was not in inode cache, reading it.\n");
142 ocfs2_read_locked_inode(inode, &args);
143 unlock_new_inode(inode);
144 }
145 if (inode == NULL) {
146 inode = ERR_PTR(-ENOMEM);
147 mlog_errno(PTR_ERR(inode));
148 goto bail;
149 }
150 if (is_bad_inode(inode)) {
151 iput(inode);
152 inode = ERR_PTR(-ESTALE);
Mark Fashehccd979b2005-12-15 14:31:24 -0800153 goto bail;
154 }
155
156bail:
157 if (!IS_ERR(inode)) {
Mark Fashehb06970532006-03-03 10:24:33 -0800158 mlog(0, "returning inode with number %llu\n",
159 (unsigned long long)OCFS2_I(inode)->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800160 mlog_exit_ptr(inode);
Mark Fasheh6a1bd4a2007-01-03 17:06:59 -0800161 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800162
163 return inode;
164}
165
166
167/*
168 * here's how inodes get read from disk:
169 * iget5_locked -> find_actor -> OCFS2_FIND_ACTOR
170 * found? : return the in-memory inode
171 * not found? : get_new_inode -> OCFS2_INIT_LOCKED_INODE
172 */
173
174static int ocfs2_find_actor(struct inode *inode, void *opaque)
175{
176 struct ocfs2_find_inode_args *args = NULL;
177 struct ocfs2_inode_info *oi = OCFS2_I(inode);
178 int ret = 0;
179
180 mlog_entry("(0x%p, %lu, 0x%p)\n", inode, inode->i_ino, opaque);
181
182 args = opaque;
183
184 mlog_bug_on_msg(!inode, "No inode in find actor!\n");
185
186 if (oi->ip_blkno != args->fi_blkno)
187 goto bail;
188
Mark Fashehccd979b2005-12-15 14:31:24 -0800189 ret = 1;
190bail:
191 mlog_exit(ret);
192 return ret;
193}
194
195/*
196 * initialize the new inode, but don't do anything that would cause
197 * us to sleep.
198 * return 0 on success, 1 on failure
199 */
200static int ocfs2_init_locked_inode(struct inode *inode, void *opaque)
201{
202 struct ocfs2_find_inode_args *args = opaque;
203
204 mlog_entry("inode = %p, opaque = %p\n", inode, opaque);
205
206 inode->i_ino = args->fi_ino;
207 OCFS2_I(inode)->ip_blkno = args->fi_blkno;
Jan Kara5fa06132008-01-11 00:11:45 +0100208 if (args->fi_sysfile_type != 0)
209 lockdep_set_class(&inode->i_mutex,
210 &ocfs2_sysfile_lock_key[args->fi_sysfile_type]);
Mark Fashehccd979b2005-12-15 14:31:24 -0800211
212 mlog_exit(0);
213 return 0;
214}
215
216int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
217 int create_ino)
218{
219 struct super_block *sb;
220 struct ocfs2_super *osb;
221 int status = -EINVAL;
222
Mark Fashehb06970532006-03-03 10:24:33 -0800223 mlog_entry("(0x%p, size:%llu)\n", inode,
Mark Fasheh1ca1a112007-04-27 16:01:25 -0700224 (unsigned long long)le64_to_cpu(fe->i_size));
Mark Fashehccd979b2005-12-15 14:31:24 -0800225
226 sb = inode->i_sb;
227 osb = OCFS2_SB(sb);
228
229 /* this means that read_inode cannot create a superblock inode
230 * today. change if needed. */
231 if (!OCFS2_IS_VALID_DINODE(fe) ||
232 !(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL))) {
Mark Fasheh6a1bd4a2007-01-03 17:06:59 -0800233 mlog(0, "Invalid dinode: i_ino=%lu, i_blkno=%llu, "
Mark Fashehccd979b2005-12-15 14:31:24 -0800234 "signature = %.*s, flags = 0x%x\n",
Mark Fashehb06970532006-03-03 10:24:33 -0800235 inode->i_ino,
236 (unsigned long long)le64_to_cpu(fe->i_blkno), 7,
Mark Fashehccd979b2005-12-15 14:31:24 -0800237 fe->i_signature, le32_to_cpu(fe->i_flags));
238 goto bail;
239 }
240
241 if (le32_to_cpu(fe->i_fs_generation) != osb->fs_generation) {
242 mlog(ML_ERROR, "file entry generation does not match "
243 "superblock! osb->fs_generation=%x, "
244 "fe->i_fs_generation=%x\n",
245 osb->fs_generation, le32_to_cpu(fe->i_fs_generation));
246 goto bail;
247 }
248
Mark Fasheh8110b072007-03-22 16:53:23 -0700249 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
250 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
Mark Fasheh15b1e362007-09-07 13:58:15 -0700251 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features);
Mark Fasheh8110b072007-03-22 16:53:23 -0700252
Mark Fashehccd979b2005-12-15 14:31:24 -0800253 inode->i_version = 1;
254 inode->i_generation = le32_to_cpu(fe->i_generation);
255 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
256 inode->i_mode = le16_to_cpu(fe->i_mode);
257 inode->i_uid = le32_to_cpu(fe->i_uid);
258 inode->i_gid = le32_to_cpu(fe->i_gid);
Mark Fashehccd979b2005-12-15 14:31:24 -0800259
260 /* Fast symlinks will have i_size but no allocated clusters. */
261 if (S_ISLNK(inode->i_mode) && !fe->i_clusters)
262 inode->i_blocks = 0;
263 else
Mark Fasheh8110b072007-03-22 16:53:23 -0700264 inode->i_blocks = ocfs2_inode_sector_count(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800265 inode->i_mapping->a_ops = &ocfs2_aops;
Mark Fashehccd979b2005-12-15 14:31:24 -0800266 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
267 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
268 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
269 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
270 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
271 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
272
273 if (OCFS2_I(inode)->ip_blkno != le64_to_cpu(fe->i_blkno))
274 mlog(ML_ERROR,
Mark Fashehb06970532006-03-03 10:24:33 -0800275 "ip_blkno %llu != i_blkno %llu!\n",
276 (unsigned long long)OCFS2_I(inode)->ip_blkno,
Mark Fasheh1ca1a112007-04-27 16:01:25 -0700277 (unsigned long long)le64_to_cpu(fe->i_blkno));
Mark Fashehccd979b2005-12-15 14:31:24 -0800278
Mark Fashehccd979b2005-12-15 14:31:24 -0800279 inode->i_nlink = le16_to_cpu(fe->i_links_count);
280
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700281 if (fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL))
282 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SYSTEM_FILE;
283
Mark Fashehccd979b2005-12-15 14:31:24 -0800284 if (fe->i_flags & cpu_to_le32(OCFS2_LOCAL_ALLOC_FL)) {
285 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
286 mlog(0, "local alloc inode: i_ino=%lu\n", inode->i_ino);
287 } else if (fe->i_flags & cpu_to_le32(OCFS2_BITMAP_FL)) {
288 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
289 } else if (fe->i_flags & cpu_to_le32(OCFS2_SUPER_BLOCK_FL)) {
290 mlog(0, "superblock inode: i_ino=%lu\n", inode->i_ino);
291 /* we can't actually hit this as read_inode can't
292 * handle superblocks today ;-) */
293 BUG();
294 }
295
296 switch (inode->i_mode & S_IFMT) {
297 case S_IFREG:
298 inode->i_fop = &ocfs2_fops;
299 inode->i_op = &ocfs2_file_iops;
300 i_size_write(inode, le64_to_cpu(fe->i_size));
301 break;
302 case S_IFDIR:
303 inode->i_op = &ocfs2_dir_iops;
304 inode->i_fop = &ocfs2_dops;
305 i_size_write(inode, le64_to_cpu(fe->i_size));
306 break;
307 case S_IFLNK:
308 if (ocfs2_inode_is_fast_symlink(inode))
309 inode->i_op = &ocfs2_fast_symlink_inode_operations;
310 else
311 inode->i_op = &ocfs2_symlink_inode_operations;
312 i_size_write(inode, le64_to_cpu(fe->i_size));
313 break;
314 default:
315 inode->i_op = &ocfs2_special_file_iops;
316 init_special_inode(inode, inode->i_mode,
317 inode->i_rdev);
318 break;
319 }
320
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700321 if (create_ino) {
322 inode->i_ino = ino_from_blkno(inode->i_sb,
323 le64_to_cpu(fe->i_blkno));
324
325 /*
326 * If we ever want to create system files from kernel,
327 * the generation argument to
328 * ocfs2_inode_lock_res_init() will have to change.
329 */
Mark Fasheh1ca1a112007-04-27 16:01:25 -0700330 BUG_ON(le32_to_cpu(fe->i_flags) & OCFS2_SYSTEM_FL);
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700331
Mark Fashehe63aecb62007-10-18 15:30:42 -0700332 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres,
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700333 OCFS2_LOCK_TYPE_META, 0, inode);
Tiger Yang50008632007-03-20 16:01:38 -0700334
335 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres,
336 OCFS2_LOCK_TYPE_OPEN, 0, inode);
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700337 }
338
Mark Fashehccd979b2005-12-15 14:31:24 -0800339 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_rw_lockres,
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700340 OCFS2_LOCK_TYPE_RW, inode->i_generation,
341 inode);
342
Herbert Poetzlca4d1472006-07-03 17:27:12 -0700343 ocfs2_set_inode_flags(inode);
Herbert Poetzlca4d1472006-07-03 17:27:12 -0700344
Mark Fashehccd979b2005-12-15 14:31:24 -0800345 status = 0;
346bail:
347 mlog_exit(status);
348 return status;
349}
350
351static int ocfs2_read_locked_inode(struct inode *inode,
352 struct ocfs2_find_inode_args *args)
353{
354 struct super_block *sb;
355 struct ocfs2_super *osb;
356 struct ocfs2_dinode *fe;
357 struct buffer_head *bh = NULL;
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700358 int status, can_lock;
359 u32 generation = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800360
361 mlog_entry("(0x%p, 0x%p)\n", inode, args);
362
363 status = -EINVAL;
364 if (inode == NULL || inode->i_sb == NULL) {
365 mlog(ML_ERROR, "bad inode\n");
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700366 return status;
Mark Fashehccd979b2005-12-15 14:31:24 -0800367 }
368 sb = inode->i_sb;
369 osb = OCFS2_SB(sb);
370
371 if (!args) {
372 mlog(ML_ERROR, "bad inode args\n");
373 make_bad_inode(inode);
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700374 return status;
Mark Fashehccd979b2005-12-15 14:31:24 -0800375 }
376
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700377 /*
378 * To improve performance of cold-cache inode stats, we take
379 * the cluster lock here if possible.
380 *
381 * Generally, OCFS2 never trusts the contents of an inode
382 * unless it's holding a cluster lock, so taking it here isn't
383 * a correctness issue as much as it is a performance
384 * improvement.
385 *
386 * There are three times when taking the lock is not a good idea:
387 *
388 * 1) During startup, before we have initialized the DLM.
389 *
390 * 2) If we are reading certain system files which never get
391 * cluster locks (local alloc, truncate log).
392 *
393 * 3) If the process doing the iget() is responsible for
394 * orphan dir recovery. We're holding the orphan dir lock and
395 * can get into a deadlock with another process on another
396 * node in ->delete_inode().
397 *
398 * #1 and #2 can be simply solved by never taking the lock
399 * here for system files (which are the only type we read
400 * during mount). It's a heavier approach, but our main
401 * concern is user-accesible files anyway.
402 *
403 * #3 works itself out because we'll eventually take the
404 * cluster lock before trusting anything anyway.
405 */
406 can_lock = !(args->fi_flags & OCFS2_FI_FLAG_SYSFILE)
Tiger Yang50008632007-03-20 16:01:38 -0700407 && !(args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY)
Sunil Mushranc271c5c2006-12-05 17:56:35 -0800408 && !ocfs2_mount_local(osb);
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700409
410 /*
411 * To maintain backwards compatibility with older versions of
412 * ocfs2-tools, we still store the generation value for system
413 * files. The only ones that actually matter to userspace are
414 * the journals, but it's easier and inexpensive to just flag
415 * all system files similarly.
416 */
417 if (args->fi_flags & OCFS2_FI_FLAG_SYSFILE)
418 generation = osb->fs_generation;
419
Mark Fashehe63aecb62007-10-18 15:30:42 -0700420 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres,
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700421 OCFS2_LOCK_TYPE_META,
422 generation, inode);
423
Tiger Yang50008632007-03-20 16:01:38 -0700424 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres,
425 OCFS2_LOCK_TYPE_OPEN,
426 0, inode);
427
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700428 if (can_lock) {
Tiger Yang50008632007-03-20 16:01:38 -0700429 status = ocfs2_open_lock(inode);
430 if (status) {
431 make_bad_inode(inode);
432 mlog_errno(status);
433 return status;
434 }
Mark Fashehe63aecb62007-10-18 15:30:42 -0700435 status = ocfs2_inode_lock(inode, NULL, 0);
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700436 if (status) {
437 make_bad_inode(inode);
438 mlog_errno(status);
439 return status;
440 }
441 }
442
Tiger Yang50008632007-03-20 16:01:38 -0700443 if (args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) {
444 status = ocfs2_try_open_lock(inode, 0);
445 if (status) {
446 make_bad_inode(inode);
447 return status;
448 }
449 }
450
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700451 status = ocfs2_read_block(osb, args->fi_blkno, &bh, 0,
452 can_lock ? inode : NULL);
Mark Fashehccd979b2005-12-15 14:31:24 -0800453 if (status < 0) {
454 mlog_errno(status);
Mark Fashehccd979b2005-12-15 14:31:24 -0800455 goto bail;
456 }
457
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700458 status = -EINVAL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800459 fe = (struct ocfs2_dinode *) bh->b_data;
460 if (!OCFS2_IS_VALID_DINODE(fe)) {
Mark Fasheha46043e02007-11-19 18:40:16 -0800461 mlog(0, "Invalid dinode #%llu: signature = %.*s\n",
462 (unsigned long long)args->fi_blkno, 7,
Mark Fasheh1ca1a112007-04-27 16:01:25 -0700463 fe->i_signature);
Mark Fashehccd979b2005-12-15 14:31:24 -0800464 goto bail;
465 }
466
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700467 /*
468 * This is a code bug. Right now the caller needs to
469 * understand whether it is asking for a system file inode or
470 * not so the proper lock names can be built.
471 */
472 mlog_bug_on_msg(!!(fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) !=
473 !!(args->fi_flags & OCFS2_FI_FLAG_SYSFILE),
474 "Inode %llu: system file state is ambigous\n",
475 (unsigned long long)args->fi_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800476
477 if (S_ISCHR(le16_to_cpu(fe->i_mode)) ||
478 S_ISBLK(le16_to_cpu(fe->i_mode)))
479 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
480
Mark Fasheh6a1bd4a2007-01-03 17:06:59 -0800481 if (ocfs2_populate_inode(inode, fe, 0) < 0)
Mark Fashehccd979b2005-12-15 14:31:24 -0800482 goto bail;
Mark Fashehccd979b2005-12-15 14:31:24 -0800483
484 BUG_ON(args->fi_blkno != le64_to_cpu(fe->i_blkno));
485
Mark Fashehccd979b2005-12-15 14:31:24 -0800486 status = 0;
487
488bail:
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700489 if (can_lock)
Mark Fashehe63aecb62007-10-18 15:30:42 -0700490 ocfs2_inode_unlock(inode, 0);
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700491
492 if (status < 0)
493 make_bad_inode(inode);
494
Mark Fashehccd979b2005-12-15 14:31:24 -0800495 if (args && bh)
496 brelse(bh);
497
498 mlog_exit(status);
499 return status;
500}
501
502void ocfs2_sync_blockdev(struct super_block *sb)
503{
504 sync_blockdev(sb->s_bdev);
505}
506
507static int ocfs2_truncate_for_delete(struct ocfs2_super *osb,
508 struct inode *inode,
509 struct buffer_head *fe_bh)
510{
511 int status = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800512 struct ocfs2_truncate_context *tc = NULL;
513 struct ocfs2_dinode *fe;
Mark Fasheh60b11392007-02-16 11:46:50 -0800514 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800515
516 mlog_entry_void();
517
518 fe = (struct ocfs2_dinode *) fe_bh->b_data;
519
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700520 /*
521 * This check will also skip truncate of inodes with inline
522 * data and fast symlinks.
523 */
Mark Fasheh3a0782d2007-01-17 12:53:31 -0800524 if (fe->i_clusters) {
Mark Fasheh60b11392007-02-16 11:46:50 -0800525 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
526 if (IS_ERR(handle)) {
527 status = PTR_ERR(handle);
528 mlog_errno(status);
529 goto out;
530 }
531
532 status = ocfs2_journal_access(handle, inode, fe_bh,
533 OCFS2_JOURNAL_ACCESS_WRITE);
534 if (status < 0) {
535 mlog_errno(status);
536 goto out;
537 }
538
539 i_size_write(inode, 0);
540
541 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
542 if (status < 0) {
543 mlog_errno(status);
544 goto out;
545 }
546
547 ocfs2_commit_trans(osb, handle);
548 handle = NULL;
549
Mark Fasheh3a0782d2007-01-17 12:53:31 -0800550 status = ocfs2_prepare_truncate(osb, inode, fe_bh, &tc);
551 if (status < 0) {
552 mlog_errno(status);
553 goto out;
554 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800555
Mark Fasheh3a0782d2007-01-17 12:53:31 -0800556 status = ocfs2_commit_truncate(osb, inode, fe_bh, tc);
557 if (status < 0) {
558 mlog_errno(status);
559 goto out;
560 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800561 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800562
Mark Fasheh60b11392007-02-16 11:46:50 -0800563out:
564 if (handle)
565 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800566 mlog_exit(status);
567 return status;
568}
569
570static int ocfs2_remove_inode(struct inode *inode,
571 struct buffer_head *di_bh,
572 struct inode *orphan_dir_inode,
573 struct buffer_head *orphan_dir_bh)
574{
575 int status;
576 struct inode *inode_alloc_inode = NULL;
577 struct buffer_head *inode_alloc_bh = NULL;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700578 handle_t *handle;
Mark Fashehccd979b2005-12-15 14:31:24 -0800579 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
580 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
581
582 inode_alloc_inode =
583 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE,
584 le16_to_cpu(di->i_suballoc_slot));
585 if (!inode_alloc_inode) {
586 status = -EEXIST;
587 mlog_errno(status);
588 goto bail;
589 }
590
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800591 mutex_lock(&inode_alloc_inode->i_mutex);
Mark Fashehe63aecb62007-10-18 15:30:42 -0700592 status = ocfs2_inode_lock(inode_alloc_inode, &inode_alloc_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800593 if (status < 0) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800594 mutex_unlock(&inode_alloc_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800595
596 mlog_errno(status);
597 goto bail;
598 }
599
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700600 handle = ocfs2_start_trans(osb, OCFS2_DELETE_INODE_CREDITS);
Mark Fashehccd979b2005-12-15 14:31:24 -0800601 if (IS_ERR(handle)) {
602 status = PTR_ERR(handle);
603 mlog_errno(status);
604 goto bail_unlock;
605 }
606
607 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
608 orphan_dir_bh);
609 if (status < 0) {
610 mlog_errno(status);
611 goto bail_commit;
612 }
613
614 /* set the inodes dtime */
615 status = ocfs2_journal_access(handle, inode, di_bh,
616 OCFS2_JOURNAL_ACCESS_WRITE);
617 if (status < 0) {
618 mlog_errno(status);
619 goto bail_commit;
620 }
621
622 di->i_dtime = cpu_to_le64(CURRENT_TIME.tv_sec);
Marcin Slusarz4092d492007-12-25 15:52:59 +0100623 di->i_flags &= cpu_to_le32(~(OCFS2_VALID_FL | OCFS2_ORPHANED_FL));
Mark Fashehccd979b2005-12-15 14:31:24 -0800624
625 status = ocfs2_journal_dirty(handle, di_bh);
626 if (status < 0) {
627 mlog_errno(status);
628 goto bail_commit;
629 }
630
631 ocfs2_remove_from_cache(inode, di_bh);
632
633 status = ocfs2_free_dinode(handle, inode_alloc_inode,
634 inode_alloc_bh, di);
635 if (status < 0)
636 mlog_errno(status);
637
638bail_commit:
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700639 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800640bail_unlock:
Mark Fashehe63aecb62007-10-18 15:30:42 -0700641 ocfs2_inode_unlock(inode_alloc_inode, 1);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800642 mutex_unlock(&inode_alloc_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800643 brelse(inode_alloc_bh);
644bail:
645 iput(inode_alloc_inode);
646
647 return status;
648}
649
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800650/*
651 * Serialize with orphan dir recovery. If the process doing
652 * recovery on this orphan dir does an iget() with the dir
653 * i_mutex held, we'll deadlock here. Instead we detect this
654 * and exit early - recovery will wipe this inode for us.
655 */
656static int ocfs2_check_orphan_recovery_state(struct ocfs2_super *osb,
657 int slot)
658{
659 int ret = 0;
660
661 spin_lock(&osb->osb_lock);
662 if (ocfs2_node_map_test_bit(osb, &osb->osb_recovering_orphan_dirs, slot)) {
663 mlog(0, "Recovery is happening on orphan dir %d, will skip "
664 "this inode\n", slot);
665 ret = -EDEADLK;
666 goto out;
667 }
668 /* This signals to the orphan recovery process that it should
669 * wait for us to handle the wipe. */
670 osb->osb_orphan_wipes[slot]++;
671out:
672 spin_unlock(&osb->osb_lock);
673 return ret;
674}
675
676static void ocfs2_signal_wipe_completion(struct ocfs2_super *osb,
677 int slot)
678{
679 spin_lock(&osb->osb_lock);
680 osb->osb_orphan_wipes[slot]--;
681 spin_unlock(&osb->osb_lock);
682
683 wake_up(&osb->osb_wipe_event);
684}
685
Mark Fashehccd979b2005-12-15 14:31:24 -0800686static int ocfs2_wipe_inode(struct inode *inode,
687 struct buffer_head *di_bh)
688{
689 int status, orphaned_slot;
690 struct inode *orphan_dir_inode = NULL;
691 struct buffer_head *orphan_dir_bh = NULL;
692 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Tiger Yang50008632007-03-20 16:01:38 -0700693 struct ocfs2_dinode *di;
Mark Fashehccd979b2005-12-15 14:31:24 -0800694
Tiger Yang50008632007-03-20 16:01:38 -0700695 di = (struct ocfs2_dinode *) di_bh->b_data;
696 orphaned_slot = le16_to_cpu(di->i_orphaned_slot);
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800697
698 status = ocfs2_check_orphan_recovery_state(osb, orphaned_slot);
699 if (status)
700 return status;
701
Mark Fashehccd979b2005-12-15 14:31:24 -0800702 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
703 ORPHAN_DIR_SYSTEM_INODE,
704 orphaned_slot);
705 if (!orphan_dir_inode) {
706 status = -EEXIST;
707 mlog_errno(status);
708 goto bail;
709 }
710
711 /* Lock the orphan dir. The lock will be held for the entire
712 * delete_inode operation. We do this now to avoid races with
713 * recovery completion on other nodes. */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800714 mutex_lock(&orphan_dir_inode->i_mutex);
Mark Fashehe63aecb62007-10-18 15:30:42 -0700715 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800716 if (status < 0) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800717 mutex_unlock(&orphan_dir_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800718
719 mlog_errno(status);
720 goto bail;
721 }
722
723 /* we do this while holding the orphan dir lock because we
Mark Fasheh34d024f2007-09-24 15:56:19 -0700724 * don't want recovery being run from another node to try an
725 * inode delete underneath us -- this will result in two nodes
Mark Fashehccd979b2005-12-15 14:31:24 -0800726 * truncating the same file! */
727 status = ocfs2_truncate_for_delete(osb, inode, di_bh);
728 if (status < 0) {
729 mlog_errno(status);
730 goto bail_unlock_dir;
731 }
732
733 status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode,
734 orphan_dir_bh);
735 if (status < 0)
736 mlog_errno(status);
737
738bail_unlock_dir:
Mark Fashehe63aecb62007-10-18 15:30:42 -0700739 ocfs2_inode_unlock(orphan_dir_inode, 1);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800740 mutex_unlock(&orphan_dir_inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -0800741 brelse(orphan_dir_bh);
742bail:
743 iput(orphan_dir_inode);
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800744 ocfs2_signal_wipe_completion(osb, orphaned_slot);
Mark Fashehccd979b2005-12-15 14:31:24 -0800745
746 return status;
747}
748
749/* There is a series of simple checks that should be done before a
Mark Fasheh34d024f2007-09-24 15:56:19 -0700750 * trylock is even considered. Encapsulate those in this function. */
Mark Fashehccd979b2005-12-15 14:31:24 -0800751static int ocfs2_inode_is_valid_to_delete(struct inode *inode)
752{
753 int ret = 0;
754 struct ocfs2_inode_info *oi = OCFS2_I(inode);
755 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
756
757 /* We shouldn't be getting here for the root directory
758 * inode.. */
759 if (inode == osb->root_inode) {
760 mlog(ML_ERROR, "Skipping delete of root inode.\n");
761 goto bail;
762 }
763
Mark Fasheh34d024f2007-09-24 15:56:19 -0700764 /* If we're coming from downconvert_thread we can't go into our own
Mark Fashehccd979b2005-12-15 14:31:24 -0800765 * voting [hello, deadlock city!], so unforuntately we just
766 * have to skip deleting this guy. That's OK though because
767 * the node who's doing the actual deleting should handle it
768 * anyway. */
Mark Fasheh34d024f2007-09-24 15:56:19 -0700769 if (current == osb->dc_task) {
Mark Fashehccd979b2005-12-15 14:31:24 -0800770 mlog(0, "Skipping delete of %lu because we're currently "
Mark Fasheh34d024f2007-09-24 15:56:19 -0700771 "in downconvert\n", inode->i_ino);
Mark Fashehccd979b2005-12-15 14:31:24 -0800772 goto bail;
773 }
774
775 spin_lock(&oi->ip_lock);
776 /* OCFS2 *never* deletes system files. This should technically
777 * never get here as system file inodes should always have a
778 * positive link count. */
779 if (oi->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
Mark Fashehb06970532006-03-03 10:24:33 -0800780 mlog(ML_ERROR, "Skipping delete of system file %llu\n",
781 (unsigned long long)oi->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800782 goto bail_unlock;
783 }
784
Mark Fasheh34d024f2007-09-24 15:56:19 -0700785 /* If we have allowd wipe of this inode for another node, it
786 * will be marked here so we can safely skip it. Recovery will
787 * cleanup any inodes we might inadvertantly skip here. */
Mark Fashehccd979b2005-12-15 14:31:24 -0800788 if (oi->ip_flags & OCFS2_INODE_SKIP_DELETE) {
789 mlog(0, "Skipping delete of %lu because another node "
790 "has done this for us.\n", inode->i_ino);
791 goto bail_unlock;
792 }
793
794 ret = 1;
795bail_unlock:
796 spin_unlock(&oi->ip_lock);
797bail:
798 return ret;
799}
800
801/* Query the cluster to determine whether we should wipe an inode from
802 * disk or not.
803 *
804 * Requires the inode to have the cluster lock. */
805static int ocfs2_query_inode_wipe(struct inode *inode,
806 struct buffer_head *di_bh,
807 int *wipe)
808{
809 int status = 0;
810 struct ocfs2_inode_info *oi = OCFS2_I(inode);
811 struct ocfs2_dinode *di;
812
813 *wipe = 0;
814
815 /* While we were waiting for the cluster lock in
816 * ocfs2_delete_inode, another node might have asked to delete
817 * the inode. Recheck our flags to catch this. */
818 if (!ocfs2_inode_is_valid_to_delete(inode)) {
Mark Fashehb06970532006-03-03 10:24:33 -0800819 mlog(0, "Skipping delete of %llu because flags changed\n",
820 (unsigned long long)oi->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800821 goto bail;
822 }
823
824 /* Now that we have an up to date inode, we can double check
825 * the link count. */
826 if (inode->i_nlink) {
Mark Fashehb06970532006-03-03 10:24:33 -0800827 mlog(0, "Skipping delete of %llu because nlink = %u\n",
828 (unsigned long long)oi->ip_blkno, inode->i_nlink);
Mark Fashehccd979b2005-12-15 14:31:24 -0800829 goto bail;
830 }
831
832 /* Do some basic inode verification... */
833 di = (struct ocfs2_dinode *) di_bh->b_data;
834 if (!(di->i_flags & cpu_to_le32(OCFS2_ORPHANED_FL))) {
835 /* for lack of a better error? */
836 status = -EEXIST;
837 mlog(ML_ERROR,
Mark Fashehb06970532006-03-03 10:24:33 -0800838 "Inode %llu (on-disk %llu) not orphaned! "
Mark Fashehccd979b2005-12-15 14:31:24 -0800839 "Disk flags 0x%x, inode flags 0x%x\n",
Mark Fashehb06970532006-03-03 10:24:33 -0800840 (unsigned long long)oi->ip_blkno,
Mark Fasheh1ca1a112007-04-27 16:01:25 -0700841 (unsigned long long)le64_to_cpu(di->i_blkno),
842 le32_to_cpu(di->i_flags), oi->ip_flags);
Mark Fashehccd979b2005-12-15 14:31:24 -0800843 goto bail;
844 }
845
846 /* has someone already deleted us?! baaad... */
847 if (di->i_dtime) {
848 status = -EEXIST;
849 mlog_errno(status);
850 goto bail;
851 }
852
Mark Fasheh6f16bf62007-03-20 17:17:54 -0700853 /*
854 * This is how ocfs2 determines whether an inode is still live
855 * within the cluster. Every node takes a shared read lock on
856 * the inode open lock in ocfs2_read_locked_inode(). When we
857 * get to ->delete_inode(), each node tries to convert it's
858 * lock to an exclusive. Trylocks are serialized by the inode
859 * meta data lock. If the upconvert suceeds, we know the inode
860 * is no longer live and can be deleted.
861 *
862 * Though we call this with the meta data lock held, the
863 * trylock keeps us from ABBA deadlock.
864 */
865 status = ocfs2_try_open_lock(inode, 1);
Tiger Yang50008632007-03-20 16:01:38 -0700866 if (status == -EAGAIN) {
Mark Fashehccd979b2005-12-15 14:31:24 -0800867 status = 0;
Joe Perches27592362007-11-19 17:53:34 -0800868 mlog(0, "Skipping delete of %llu because it is in use on "
Mark Fashehb06970532006-03-03 10:24:33 -0800869 "other nodes\n", (unsigned long long)oi->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800870 goto bail;
871 }
872 if (status < 0) {
873 mlog_errno(status);
874 goto bail;
875 }
876
Tiger Yang50008632007-03-20 16:01:38 -0700877 *wipe = 1;
878 mlog(0, "Inode %llu is ok to wipe from orphan dir %u\n",
879 (unsigned long long)oi->ip_blkno,
880 le16_to_cpu(di->i_orphaned_slot));
Mark Fashehccd979b2005-12-15 14:31:24 -0800881
882bail:
883 return status;
884}
885
886/* Support function for ocfs2_delete_inode. Will help us keep the
887 * inode data in a consistent state for clear_inode. Always truncates
888 * pages, optionally sync's them first. */
889static void ocfs2_cleanup_delete_inode(struct inode *inode,
890 int sync_data)
891{
Mark Fashehb06970532006-03-03 10:24:33 -0800892 mlog(0, "Cleanup inode %llu, sync = %d\n",
893 (unsigned long long)OCFS2_I(inode)->ip_blkno, sync_data);
Mark Fashehccd979b2005-12-15 14:31:24 -0800894 if (sync_data)
895 write_inode_now(inode, 1);
896 truncate_inode_pages(&inode->i_data, 0);
897}
898
899void ocfs2_delete_inode(struct inode *inode)
900{
901 int wipe, status;
902 sigset_t blocked, oldset;
903 struct buffer_head *di_bh = NULL;
904
905 mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
906
907 if (is_bad_inode(inode)) {
908 mlog(0, "Skipping delete of bad inode\n");
909 goto bail;
910 }
911
912 if (!ocfs2_inode_is_valid_to_delete(inode)) {
913 /* It's probably not necessary to truncate_inode_pages
914 * here but we do it for safety anyway (it will most
915 * likely be a no-op anyway) */
916 ocfs2_cleanup_delete_inode(inode, 0);
917 goto bail;
918 }
919
920 /* We want to block signals in delete_inode as the lock and
921 * messaging paths may return us -ERESTARTSYS. Which would
922 * cause us to exit early, resulting in inodes being orphaned
923 * forever. */
924 sigfillset(&blocked);
925 status = sigprocmask(SIG_BLOCK, &blocked, &oldset);
926 if (status < 0) {
927 mlog_errno(status);
928 ocfs2_cleanup_delete_inode(inode, 1);
929 goto bail;
930 }
931
932 /* Lock down the inode. This gives us an up to date view of
933 * it's metadata (for verification), and allows us to
Mark Fasheh34d024f2007-09-24 15:56:19 -0700934 * serialize delete_inode on multiple nodes.
Mark Fashehccd979b2005-12-15 14:31:24 -0800935 *
936 * Even though we might be doing a truncate, we don't take the
937 * allocation lock here as it won't be needed - nobody will
938 * have the file open.
939 */
Mark Fashehe63aecb62007-10-18 15:30:42 -0700940 status = ocfs2_inode_lock(inode, &di_bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800941 if (status < 0) {
942 if (status != -ENOENT)
943 mlog_errno(status);
944 ocfs2_cleanup_delete_inode(inode, 0);
945 goto bail_unblock;
946 }
947
948 /* Query the cluster. This will be the final decision made
949 * before we go ahead and wipe the inode. */
950 status = ocfs2_query_inode_wipe(inode, di_bh, &wipe);
951 if (!wipe || status < 0) {
Mark Fasheh34d024f2007-09-24 15:56:19 -0700952 /* Error and remote inode busy both mean we won't be
Mark Fashehccd979b2005-12-15 14:31:24 -0800953 * removing the inode, so they take almost the same
954 * path. */
955 if (status < 0)
956 mlog_errno(status);
957
Mark Fasheh34d024f2007-09-24 15:56:19 -0700958 /* Someone in the cluster has disallowed a wipe of
959 * this inode, or it was never completely
960 * orphaned. Write out the pages and exit now. */
Mark Fashehccd979b2005-12-15 14:31:24 -0800961 ocfs2_cleanup_delete_inode(inode, 1);
962 goto bail_unlock_inode;
963 }
964
965 ocfs2_cleanup_delete_inode(inode, 0);
966
967 status = ocfs2_wipe_inode(inode, di_bh);
968 if (status < 0) {
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800969 if (status != -EDEADLK)
970 mlog_errno(status);
Mark Fashehccd979b2005-12-15 14:31:24 -0800971 goto bail_unlock_inode;
972 }
973
Mark Fasheh24c19ef2006-09-22 17:28:19 -0700974 /*
975 * Mark the inode as successfully deleted.
976 *
977 * This is important for ocfs2_clear_inode() as it will check
978 * this flag and skip any checkpointing work
979 *
980 * ocfs2_stuff_meta_lvb() also uses this flag to invalidate
981 * the LVB for other nodes.
982 */
Mark Fashehccd979b2005-12-15 14:31:24 -0800983 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_DELETED;
984
985bail_unlock_inode:
Mark Fashehe63aecb62007-10-18 15:30:42 -0700986 ocfs2_inode_unlock(inode, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800987 brelse(di_bh);
988bail_unblock:
989 status = sigprocmask(SIG_SETMASK, &oldset, NULL);
990 if (status < 0)
991 mlog_errno(status);
992bail:
993 clear_inode(inode);
994 mlog_exit_void();
995}
996
997void ocfs2_clear_inode(struct inode *inode)
998{
999 int status;
1000 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1001
1002 mlog_entry_void();
1003
1004 if (!inode)
1005 goto bail;
1006
Mark Fashehb06970532006-03-03 10:24:33 -08001007 mlog(0, "Clearing inode: %llu, nlink = %u\n",
1008 (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_nlink);
Mark Fashehccd979b2005-12-15 14:31:24 -08001009
1010 mlog_bug_on_msg(OCFS2_SB(inode->i_sb) == NULL,
1011 "Inode=%lu\n", inode->i_ino);
1012
Mark Fasheh34d024f2007-09-24 15:56:19 -07001013 /* To preven remote deletes we hold open lock before, now it
1014 * is time to unlock PR and EX open locks. */
Tiger Yang50008632007-03-20 16:01:38 -07001015 ocfs2_open_unlock(inode);
1016
Mark Fashehccd979b2005-12-15 14:31:24 -08001017 /* Do these before all the other work so that we don't bounce
Mark Fasheh34d024f2007-09-24 15:56:19 -07001018 * the downconvert thread while waiting to destroy the locks. */
Mark Fashehccd979b2005-12-15 14:31:24 -08001019 ocfs2_mark_lockres_freeing(&oi->ip_rw_lockres);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001020 ocfs2_mark_lockres_freeing(&oi->ip_inode_lockres);
Tiger Yang50008632007-03-20 16:01:38 -07001021 ocfs2_mark_lockres_freeing(&oi->ip_open_lockres);
Mark Fashehccd979b2005-12-15 14:31:24 -08001022
1023 /* We very well may get a clear_inode before all an inodes
1024 * metadata has hit disk. Of course, we can't drop any cluster
1025 * locks until the journal has finished with it. The only
1026 * exception here are successfully wiped inodes - their
1027 * metadata can now be considered to be part of the system
1028 * inodes from which it came. */
1029 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED))
1030 ocfs2_checkpoint_inode(inode);
1031
1032 mlog_bug_on_msg(!list_empty(&oi->ip_io_markers),
Mark Fashehb06970532006-03-03 10:24:33 -08001033 "Clear inode of %llu, inode has io markers\n",
1034 (unsigned long long)oi->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -08001035
Mark Fasheh83418972007-04-23 18:53:12 -07001036 ocfs2_extent_map_trunc(inode, 0);
1037
Mark Fashehccd979b2005-12-15 14:31:24 -08001038 status = ocfs2_drop_inode_locks(inode);
1039 if (status < 0)
1040 mlog_errno(status);
1041
1042 ocfs2_lock_res_free(&oi->ip_rw_lockres);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001043 ocfs2_lock_res_free(&oi->ip_inode_lockres);
Tiger Yang50008632007-03-20 16:01:38 -07001044 ocfs2_lock_res_free(&oi->ip_open_lockres);
Mark Fashehccd979b2005-12-15 14:31:24 -08001045
1046 ocfs2_metadata_cache_purge(inode);
1047
1048 mlog_bug_on_msg(oi->ip_metadata_cache.ci_num_cached,
Mark Fashehb06970532006-03-03 10:24:33 -08001049 "Clear inode of %llu, inode has %u cache items\n",
1050 (unsigned long long)oi->ip_blkno, oi->ip_metadata_cache.ci_num_cached);
Mark Fashehccd979b2005-12-15 14:31:24 -08001051
1052 mlog_bug_on_msg(!(oi->ip_flags & OCFS2_INODE_CACHE_INLINE),
Mark Fashehb06970532006-03-03 10:24:33 -08001053 "Clear inode of %llu, inode has a bad flag\n",
1054 (unsigned long long)oi->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -08001055
1056 mlog_bug_on_msg(spin_is_locked(&oi->ip_lock),
Mark Fashehb06970532006-03-03 10:24:33 -08001057 "Clear inode of %llu, inode is locked\n",
1058 (unsigned long long)oi->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -08001059
Mark Fasheh251b6ec2006-01-10 15:41:43 -08001060 mlog_bug_on_msg(!mutex_trylock(&oi->ip_io_mutex),
Mark Fashehb06970532006-03-03 10:24:33 -08001061 "Clear inode of %llu, io_mutex is locked\n",
1062 (unsigned long long)oi->ip_blkno);
Mark Fasheh251b6ec2006-01-10 15:41:43 -08001063 mutex_unlock(&oi->ip_io_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -08001064
1065 /*
1066 * down_trylock() returns 0, down_write_trylock() returns 1
1067 * kernel 1, world 0
1068 */
1069 mlog_bug_on_msg(!down_write_trylock(&oi->ip_alloc_sem),
Mark Fashehb06970532006-03-03 10:24:33 -08001070 "Clear inode of %llu, alloc_sem is locked\n",
1071 (unsigned long long)oi->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -08001072 up_write(&oi->ip_alloc_sem);
1073
1074 mlog_bug_on_msg(oi->ip_open_count,
Mark Fashehb06970532006-03-03 10:24:33 -08001075 "Clear inode of %llu has open count %d\n",
1076 (unsigned long long)oi->ip_blkno, oi->ip_open_count);
Mark Fashehccd979b2005-12-15 14:31:24 -08001077
1078 /* Clear all other flags. */
1079 oi->ip_flags = OCFS2_INODE_CACHE_INLINE;
1080 oi->ip_created_trans = 0;
1081 oi->ip_last_trans = 0;
1082 oi->ip_dir_start_lookup = 0;
1083 oi->ip_blkno = 0ULL;
1084
1085bail:
1086 mlog_exit_void();
1087}
1088
1089/* Called under inode_lock, with no more references on the
1090 * struct inode, so it's safe here to check the flags field
1091 * and to manipulate i_nlink without any other locks. */
1092void ocfs2_drop_inode(struct inode *inode)
1093{
1094 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1095
1096 mlog_entry_void();
1097
Mark Fashehb06970532006-03-03 10:24:33 -08001098 mlog(0, "Drop inode %llu, nlink = %u, ip_flags = 0x%x\n",
1099 (unsigned long long)oi->ip_blkno, inode->i_nlink, oi->ip_flags);
Mark Fashehccd979b2005-12-15 14:31:24 -08001100
Mark Fasheh379dfe92006-09-08 14:21:03 -07001101 if (oi->ip_flags & OCFS2_INODE_MAYBE_ORPHANED)
1102 generic_delete_inode(inode);
1103 else
1104 generic_drop_inode(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001105
1106 mlog_exit_void();
1107}
1108
1109/*
1110 * TODO: this should probably be merged into ocfs2_get_block
1111 *
1112 * However, you now need to pay attention to the cont_prepare_write()
1113 * stuff in ocfs2_get_block (that is, ocfs2_get_block pretty much
1114 * expects never to extend).
1115 */
1116struct buffer_head *ocfs2_bread(struct inode *inode,
1117 int block, int *err, int reada)
1118{
1119 struct buffer_head *bh = NULL;
1120 int tmperr;
1121 u64 p_blkno;
1122 int readflags = OCFS2_BH_CACHED;
1123
Mark Fashehccd979b2005-12-15 14:31:24 -08001124 if (reada)
1125 readflags |= OCFS2_BH_READAHEAD;
Mark Fashehccd979b2005-12-15 14:31:24 -08001126
1127 if (((u64)block << inode->i_sb->s_blocksize_bits) >=
1128 i_size_read(inode)) {
1129 BUG_ON(!reada);
1130 return NULL;
1131 }
1132
Joel Beckeree19a772007-03-28 18:27:07 -07001133 down_read(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001134 tmperr = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
1135 NULL);
Joel Beckeree19a772007-03-28 18:27:07 -07001136 up_read(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fashehccd979b2005-12-15 14:31:24 -08001137 if (tmperr < 0) {
1138 mlog_errno(tmperr);
1139 goto fail;
1140 }
1141
1142 tmperr = ocfs2_read_block(OCFS2_SB(inode->i_sb), p_blkno, &bh,
1143 readflags, inode);
1144 if (tmperr < 0)
1145 goto fail;
1146
1147 tmperr = 0;
1148
1149 *err = 0;
1150 return bh;
1151
1152fail:
1153 if (bh) {
1154 brelse(bh);
1155 bh = NULL;
1156 }
1157 *err = -EIO;
1158 return NULL;
1159}
1160
1161/*
1162 * This is called from our getattr.
1163 */
1164int ocfs2_inode_revalidate(struct dentry *dentry)
1165{
1166 struct inode *inode = dentry->d_inode;
1167 int status = 0;
1168
Mark Fashehb06970532006-03-03 10:24:33 -08001169 mlog_entry("(inode = 0x%p, ino = %llu)\n", inode,
1170 inode ? (unsigned long long)OCFS2_I(inode)->ip_blkno : 0ULL);
Mark Fashehccd979b2005-12-15 14:31:24 -08001171
1172 if (!inode) {
1173 mlog(0, "eep, no inode!\n");
1174 status = -ENOENT;
1175 goto bail;
1176 }
1177
1178 spin_lock(&OCFS2_I(inode)->ip_lock);
1179 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
1180 spin_unlock(&OCFS2_I(inode)->ip_lock);
1181 mlog(0, "inode deleted!\n");
1182 status = -ENOENT;
1183 goto bail;
1184 }
1185 spin_unlock(&OCFS2_I(inode)->ip_lock);
1186
Mark Fashehe63aecb62007-10-18 15:30:42 -07001187 /* Let ocfs2_inode_lock do the work of updating our struct
Mark Fashehccd979b2005-12-15 14:31:24 -08001188 * inode for us. */
Mark Fashehe63aecb62007-10-18 15:30:42 -07001189 status = ocfs2_inode_lock(inode, NULL, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -08001190 if (status < 0) {
1191 if (status != -ENOENT)
1192 mlog_errno(status);
1193 goto bail;
1194 }
Mark Fashehe63aecb62007-10-18 15:30:42 -07001195 ocfs2_inode_unlock(inode, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -08001196bail:
1197 mlog_exit(status);
1198
1199 return status;
1200}
1201
1202/*
1203 * Updates a disk inode from a
1204 * struct inode.
1205 * Only takes ip_lock.
1206 */
Mark Fasheh1fabe142006-10-09 18:11:45 -07001207int ocfs2_mark_inode_dirty(handle_t *handle,
Mark Fashehccd979b2005-12-15 14:31:24 -08001208 struct inode *inode,
1209 struct buffer_head *bh)
1210{
1211 int status;
1212 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
1213
Mark Fashehb06970532006-03-03 10:24:33 -08001214 mlog_entry("(inode %llu)\n",
1215 (unsigned long long)OCFS2_I(inode)->ip_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -08001216
1217 status = ocfs2_journal_access(handle, inode, bh,
1218 OCFS2_JOURNAL_ACCESS_WRITE);
1219 if (status < 0) {
1220 mlog_errno(status);
1221 goto leave;
1222 }
1223
1224 spin_lock(&OCFS2_I(inode)->ip_lock);
1225 fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
Jan Kara6e4b0d52007-04-27 11:08:01 -07001226 ocfs2_get_inode_flags(OCFS2_I(inode));
Herbert Poetzlca4d1472006-07-03 17:27:12 -07001227 fe->i_attr = cpu_to_le32(OCFS2_I(inode)->ip_attr);
Mark Fasheh15b1e362007-09-07 13:58:15 -07001228 fe->i_dyn_features = cpu_to_le16(OCFS2_I(inode)->ip_dyn_features);
Mark Fashehccd979b2005-12-15 14:31:24 -08001229 spin_unlock(&OCFS2_I(inode)->ip_lock);
1230
1231 fe->i_size = cpu_to_le64(i_size_read(inode));
1232 fe->i_links_count = cpu_to_le16(inode->i_nlink);
1233 fe->i_uid = cpu_to_le32(inode->i_uid);
1234 fe->i_gid = cpu_to_le32(inode->i_gid);
1235 fe->i_mode = cpu_to_le16(inode->i_mode);
1236 fe->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
1237 fe->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
1238 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
1239 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
1240 fe->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
1241 fe->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
1242
1243 status = ocfs2_journal_dirty(handle, bh);
1244 if (status < 0)
1245 mlog_errno(status);
1246
1247 status = 0;
1248leave:
1249
1250 mlog_exit(status);
1251 return status;
1252}
1253
1254/*
1255 *
1256 * Updates a struct inode from a disk inode.
1257 * does no i/o, only takes ip_lock.
1258 */
1259void ocfs2_refresh_inode(struct inode *inode,
1260 struct ocfs2_dinode *fe)
1261{
Mark Fashehccd979b2005-12-15 14:31:24 -08001262 spin_lock(&OCFS2_I(inode)->ip_lock);
1263
1264 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
Herbert Poetzlca4d1472006-07-03 17:27:12 -07001265 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
Mark Fasheh15b1e362007-09-07 13:58:15 -07001266 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features);
Herbert Poetzlca4d1472006-07-03 17:27:12 -07001267 ocfs2_set_inode_flags(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001268 i_size_write(inode, le64_to_cpu(fe->i_size));
1269 inode->i_nlink = le16_to_cpu(fe->i_links_count);
1270 inode->i_uid = le32_to_cpu(fe->i_uid);
1271 inode->i_gid = le32_to_cpu(fe->i_gid);
1272 inode->i_mode = le16_to_cpu(fe->i_mode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001273 if (S_ISLNK(inode->i_mode) && le32_to_cpu(fe->i_clusters) == 0)
1274 inode->i_blocks = 0;
1275 else
Mark Fasheh8110b072007-03-22 16:53:23 -07001276 inode->i_blocks = ocfs2_inode_sector_count(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001277 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
1278 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
1279 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
1280 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
1281 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime);
1282 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec);
1283
1284 spin_unlock(&OCFS2_I(inode)->ip_lock);
1285}