inode.c 16.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
 *  linux/fs/hfsplus/inode.c
 *
 * Copyright (C) 2001
 * Brad Boyer (flar@allandria.com)
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * Inode handling routines
 */

#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/mpage.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
15
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include "hfsplus_fs.h"
#include "hfsplus_raw.h"

static int hfsplus_readpage(struct file *file, struct page *page)
{
	return block_read_full_page(page, hfsplus_get_block);
}

static int hfsplus_writepage(struct page *page, struct writeback_control *wbc)
{
	return block_write_full_page(page, hfsplus_get_block, wbc);
}

Nick Piggin's avatar
Nick Piggin committed
30
31
32
static int hfsplus_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
Linus Torvalds's avatar
Linus Torvalds committed
33
{
34
35
	int ret;

Nick Piggin's avatar
Nick Piggin committed
36
	*pagep = NULL;
37
	ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
Nick Piggin's avatar
Nick Piggin committed
38
				hfsplus_get_block,
39
				&HFSPLUS_I(mapping->host)->phys_size);
40
41
42
43
44
45
46
	if (unlikely(ret)) {
		loff_t isize = mapping->host->i_size;
		if (pos + len > isize)
			vmtruncate(mapping->host, isize);
	}

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
47
48
49
50
51
52
53
}

static sector_t hfsplus_bmap(struct address_space *mapping, sector_t block)
{
	return generic_block_bmap(mapping, block, hfsplus_get_block);
}

Al Viro's avatar
Al Viro committed
54
static int hfsplus_releasepage(struct page *page, gfp_t mask)
Linus Torvalds's avatar
Linus Torvalds committed
55
56
57
58
59
60
61
62
63
64
{
	struct inode *inode = page->mapping->host;
	struct super_block *sb = inode->i_sb;
	struct hfs_btree *tree;
	struct hfs_bnode *node;
	u32 nidx;
	int i, res = 1;

	switch (inode->i_ino) {
	case HFSPLUS_EXT_CNID:
65
		tree = HFSPLUS_SB(sb)->ext_tree;
Linus Torvalds's avatar
Linus Torvalds committed
66
67
		break;
	case HFSPLUS_CAT_CNID:
68
		tree = HFSPLUS_SB(sb)->cat_tree;
Linus Torvalds's avatar
Linus Torvalds committed
69
70
		break;
	case HFSPLUS_ATTR_CNID:
71
		tree = HFSPLUS_SB(sb)->attr_tree;
Linus Torvalds's avatar
Linus Torvalds committed
72
73
74
75
76
		break;
	default:
		BUG();
		return 0;
	}
77
78
	if (!tree)
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
	if (tree->node_size >= PAGE_CACHE_SIZE) {
		nidx = page->index >> (tree->node_size_shift - PAGE_CACHE_SHIFT);
		spin_lock(&tree->hash_lock);
		node = hfs_bnode_findhash(tree, nidx);
		if (!node)
			;
		else if (atomic_read(&node->refcnt))
			res = 0;
		if (res && node) {
			hfs_bnode_unhash(node);
			hfs_bnode_free(node);
		}
		spin_unlock(&tree->hash_lock);
	} else {
		nidx = page->index << (PAGE_CACHE_SHIFT - tree->node_size_shift);
		i = 1 << (PAGE_CACHE_SHIFT - tree->node_size_shift);
		spin_lock(&tree->hash_lock);
		do {
			node = hfs_bnode_findhash(tree, nidx++);
			if (!node)
				continue;
			if (atomic_read(&node->refcnt)) {
				res = 0;
				break;
			}
			hfs_bnode_unhash(node);
			hfs_bnode_free(node);
		} while (--i && nidx < tree->node_count);
		spin_unlock(&tree->hash_lock);
	}
	return res ? try_to_free_buffers(page) : 0;
}

static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
		const struct iovec *iov, loff_t offset, unsigned long nr_segs)
{
	struct file *file = iocb->ki_filp;
116
	struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
117
	ssize_t ret;
Linus Torvalds's avatar
Linus Torvalds committed
118

119
	ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
120
				  offset, nr_segs, hfsplus_get_block, NULL);
121
122
123
124
125
126
127
128
129
130
131
132
133
134

	/*
	 * In case of error extending write may have instantiated a few
	 * blocks outside i_size. Trim these off again.
	 */
	if (unlikely((rw & WRITE) && ret < 0)) {
		loff_t isize = i_size_read(inode);
		loff_t end = offset + iov_length(iov, nr_segs);

		if (end > isize)
			vmtruncate(inode, isize);
	}

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
135
136
137
138
139
140
141
142
}

static int hfsplus_writepages(struct address_space *mapping,
			      struct writeback_control *wbc)
{
	return mpage_writepages(mapping, wbc, hfsplus_get_block);
}

143
const struct address_space_operations hfsplus_btree_aops = {
Linus Torvalds's avatar
Linus Torvalds committed
144
145
146
	.readpage	= hfsplus_readpage,
	.writepage	= hfsplus_writepage,
	.sync_page	= block_sync_page,
Nick Piggin's avatar
Nick Piggin committed
147
148
	.write_begin	= hfsplus_write_begin,
	.write_end	= generic_write_end,
Linus Torvalds's avatar
Linus Torvalds committed
149
150
151
152
	.bmap		= hfsplus_bmap,
	.releasepage	= hfsplus_releasepage,
};

153
const struct address_space_operations hfsplus_aops = {
Linus Torvalds's avatar
Linus Torvalds committed
154
155
156
	.readpage	= hfsplus_readpage,
	.writepage	= hfsplus_writepage,
	.sync_page	= block_sync_page,
Nick Piggin's avatar
Nick Piggin committed
157
158
	.write_begin	= hfsplus_write_begin,
	.write_end	= generic_write_end,
Linus Torvalds's avatar
Linus Torvalds committed
159
160
161
162
163
	.bmap		= hfsplus_bmap,
	.direct_IO	= hfsplus_direct_IO,
	.writepages	= hfsplus_writepages,
};

164
const struct dentry_operations hfsplus_dentry_operations = {
165
166
167
168
	.d_hash       = hfsplus_hash_dentry,
	.d_compare    = hfsplus_compare_dentry,
};

Linus Torvalds's avatar
Linus Torvalds committed
169
170
171
172
173
174
static struct dentry *hfsplus_file_lookup(struct inode *dir, struct dentry *dentry,
					  struct nameidata *nd)
{
	struct hfs_find_data fd;
	struct super_block *sb = dir->i_sb;
	struct inode *inode = NULL;
175
	struct hfsplus_inode_info *hip;
Linus Torvalds's avatar
Linus Torvalds committed
176
177
178
179
180
	int err;

	if (HFSPLUS_IS_RSRC(dir) || strcmp(dentry->d_name.name, "rsrc"))
		goto out;

181
	inode = HFSPLUS_I(dir)->rsrc_inode;
Linus Torvalds's avatar
Linus Torvalds committed
182
183
184
185
186
187
188
	if (inode)
		goto out;

	inode = new_inode(sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

189
	hip = HFSPLUS_I(inode);
Linus Torvalds's avatar
Linus Torvalds committed
190
	inode->i_ino = dir->i_ino;
191
192
193
	INIT_LIST_HEAD(&hip->open_dir_list);
	mutex_init(&hip->extents_lock);
	hip->flags = HFSPLUS_FLG_RSRC;
Linus Torvalds's avatar
Linus Torvalds committed
194

195
	hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
Linus Torvalds's avatar
Linus Torvalds committed
196
197
198
199
200
201
202
203
	err = hfsplus_find_cat(sb, dir->i_ino, &fd);
	if (!err)
		err = hfsplus_cat_read_inode(inode, &fd);
	hfs_find_exit(&fd);
	if (err) {
		iput(inode);
		return ERR_PTR(err);
	}
204
205
	hip->rsrc_inode = dir;
	HFSPLUS_I(dir)->rsrc_inode = inode;
Linus Torvalds's avatar
Linus Torvalds committed
206
	igrab(dir);
207
208
209
210
211
212
213

	/*
	 * __mark_inode_dirty expects inodes to be hashed.  Since we don't
	 * want resource fork inodes in the regular inode space, we make them
	 * appear hashed, but do not put on any lists.  hlist_del()
	 * will work fine and require no locking.
	 */
214
	hlist_add_fake(&inode->i_hash);
215

Linus Torvalds's avatar
Linus Torvalds committed
216
217
218
219
220
221
222
223
	mark_inode_dirty(inode);
out:
	d_add(dentry, inode);
	return NULL;
}

static void hfsplus_get_perms(struct inode *inode, struct hfsplus_perm *perms, int dir)
{
224
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
Linus Torvalds's avatar
Linus Torvalds committed
225
226
227
228
229
230
	u16 mode;

	mode = be16_to_cpu(perms->mode);

	inode->i_uid = be32_to_cpu(perms->owner);
	if (!inode->i_uid && !mode)
231
		inode->i_uid = sbi->uid;
Linus Torvalds's avatar
Linus Torvalds committed
232
233
234

	inode->i_gid = be32_to_cpu(perms->group);
	if (!inode->i_gid && !mode)
235
		inode->i_gid = sbi->gid;
Linus Torvalds's avatar
Linus Torvalds committed
236
237

	if (dir) {
238
		mode = mode ? (mode & S_IALLUGO) : (S_IRWXUGO & ~(sbi->umask));
Linus Torvalds's avatar
Linus Torvalds committed
239
240
		mode |= S_IFDIR;
	} else if (!mode)
241
		mode = S_IFREG | ((S_IRUGO|S_IWUGO) & ~(sbi->umask));
Linus Torvalds's avatar
Linus Torvalds committed
242
243
	inode->i_mode = mode;

244
	HFSPLUS_I(inode)->userflags = perms->userflags;
Linus Torvalds's avatar
Linus Torvalds committed
245
246
247
248
249
250
251
252
253
254
255
256
257
	if (perms->rootflags & HFSPLUS_FLG_IMMUTABLE)
		inode->i_flags |= S_IMMUTABLE;
	else
		inode->i_flags &= ~S_IMMUTABLE;
	if (perms->rootflags & HFSPLUS_FLG_APPEND)
		inode->i_flags |= S_APPEND;
	else
		inode->i_flags &= ~S_APPEND;
}

static int hfsplus_file_open(struct inode *inode, struct file *file)
{
	if (HFSPLUS_IS_RSRC(inode))
258
		inode = HFSPLUS_I(inode)->rsrc_inode;
Alan Cox's avatar
Alan Cox committed
259
260
	if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
		return -EOVERFLOW;
261
	atomic_inc(&HFSPLUS_I(inode)->opencnt);
Linus Torvalds's avatar
Linus Torvalds committed
262
263
264
265
266
267
268
269
	return 0;
}

static int hfsplus_file_release(struct inode *inode, struct file *file)
{
	struct super_block *sb = inode->i_sb;

	if (HFSPLUS_IS_RSRC(inode))
270
271
		inode = HFSPLUS_I(inode)->rsrc_inode;
	if (atomic_dec_and_test(&HFSPLUS_I(inode)->opencnt)) {
272
		mutex_lock(&inode->i_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
273
274
		hfsplus_file_truncate(inode);
		if (inode->i_flags & S_DEAD) {
275
276
			hfsplus_delete_cat(inode->i_ino,
					   HFSPLUS_SB(sb)->hidden_dir, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
277
278
			hfsplus_delete_inode(inode);
		}
279
		mutex_unlock(&inode->i_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
280
281
282
283
	}
	return 0;
}

284
285
286
287
288
289
290
291
static int hfsplus_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	int error;

	error = inode_change_ok(inode, attr);
	if (error)
		return error;
Christoph Hellwig's avatar
Christoph Hellwig committed
292
293
294
295
296
297
298
299
300
301
302

	if ((attr->ia_valid & ATTR_SIZE) &&
	    attr->ia_size != i_size_read(inode)) {
		error = vmtruncate(inode, attr->ia_size);
		if (error)
			return error;
	}

	setattr_copy(inode, attr);
	mark_inode_dirty(inode);
	return 0;
303
304
}

Al Viro's avatar
Al Viro committed
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
static int hfsplus_file_fsync(struct file *filp, int datasync)
{
	struct inode *inode = filp->f_mapping->host;
	struct super_block * sb;
	int ret, err;

	/* sync the inode to buffers */
	ret = write_inode_now(inode, 0);

	/* sync the superblock to buffers */
	sb = inode->i_sb;
	if (sb->s_dirt) {
		if (!(sb->s_flags & MS_RDONLY))
			hfsplus_sync_fs(sb, 1);
		else
			sb->s_dirt = 0;
	}

	/* .. finally sync the buffers to disk */
	err = sync_blockdev(sb->s_bdev);
	if (!ret)
		ret = err;
	return ret;
}

330
static const struct inode_operations hfsplus_file_inode_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
331
332
	.lookup		= hfsplus_file_lookup,
	.truncate	= hfsplus_file_truncate,
333
	.setattr	= hfsplus_setattr,
Linus Torvalds's avatar
Linus Torvalds committed
334
335
336
337
338
	.setxattr	= hfsplus_setxattr,
	.getxattr	= hfsplus_getxattr,
	.listxattr	= hfsplus_listxattr,
};

339
static const struct file_operations hfsplus_file_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
340
	.llseek 	= generic_file_llseek,
341
342
343
344
	.read		= do_sync_read,
	.aio_read	= generic_file_aio_read,
	.write		= do_sync_write,
	.aio_write	= generic_file_aio_write,
Linus Torvalds's avatar
Linus Torvalds committed
345
	.mmap		= generic_file_mmap,
346
	.splice_read	= generic_file_splice_read,
Al Viro's avatar
Al Viro committed
347
	.fsync		= hfsplus_file_fsync,
Linus Torvalds's avatar
Linus Torvalds committed
348
349
	.open		= hfsplus_file_open,
	.release	= hfsplus_file_release,
350
	.unlocked_ioctl = hfsplus_ioctl,
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
354
};

struct inode *hfsplus_new_inode(struct super_block *sb, int mode)
{
355
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
Linus Torvalds's avatar
Linus Torvalds committed
356
	struct inode *inode = new_inode(sb);
357
	struct hfsplus_inode_info *hip;
358

Linus Torvalds's avatar
Linus Torvalds committed
359
360
361
	if (!inode)
		return NULL;

362
	inode->i_ino = sbi->next_cnid++;
Linus Torvalds's avatar
Linus Torvalds committed
363
	inode->i_mode = mode;
364
365
	inode->i_uid = current_fsuid();
	inode->i_gid = current_fsgid();
Linus Torvalds's avatar
Linus Torvalds committed
366
367
	inode->i_nlink = 1;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382

	hip = HFSPLUS_I(inode);
	INIT_LIST_HEAD(&hip->open_dir_list);
	mutex_init(&hip->extents_lock);
	atomic_set(&hip->opencnt, 0);
	hip->flags = 0;
	memset(hip->first_extents, 0, sizeof(hfsplus_extent_rec));
	memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec));
	hip->alloc_blocks = 0;
	hip->first_blocks = 0;
	hip->cached_start = 0;
	hip->cached_blocks = 0;
	hip->phys_size = 0;
	hip->fs_blocks = 0;
	hip->rsrc_inode = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
383
384
	if (S_ISDIR(inode->i_mode)) {
		inode->i_size = 2;
385
		sbi->folder_count++;
Linus Torvalds's avatar
Linus Torvalds committed
386
387
388
		inode->i_op = &hfsplus_dir_inode_operations;
		inode->i_fop = &hfsplus_dir_operations;
	} else if (S_ISREG(inode->i_mode)) {
389
		sbi->file_count++;
Linus Torvalds's avatar
Linus Torvalds committed
390
391
392
		inode->i_op = &hfsplus_file_inode_operations;
		inode->i_fop = &hfsplus_file_operations;
		inode->i_mapping->a_ops = &hfsplus_aops;
393
		hip->clump_blocks = sbi->data_clump_blocks;
Linus Torvalds's avatar
Linus Torvalds committed
394
	} else if (S_ISLNK(inode->i_mode)) {
395
		sbi->file_count++;
Linus Torvalds's avatar
Linus Torvalds committed
396
397
		inode->i_op = &page_symlink_inode_operations;
		inode->i_mapping->a_ops = &hfsplus_aops;
398
		hip->clump_blocks = 1;
Linus Torvalds's avatar
Linus Torvalds committed
399
	} else
400
		sbi->file_count++;
Linus Torvalds's avatar
Linus Torvalds committed
401
402
403
404
405
406
407
408
409
410
411
412
	insert_inode_hash(inode);
	mark_inode_dirty(inode);
	sb->s_dirt = 1;

	return inode;
}

void hfsplus_delete_inode(struct inode *inode)
{
	struct super_block *sb = inode->i_sb;

	if (S_ISDIR(inode->i_mode)) {
413
		HFSPLUS_SB(sb)->folder_count--;
Linus Torvalds's avatar
Linus Torvalds committed
414
415
416
		sb->s_dirt = 1;
		return;
	}
417
	HFSPLUS_SB(sb)->file_count--;
Linus Torvalds's avatar
Linus Torvalds committed
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
	if (S_ISREG(inode->i_mode)) {
		if (!inode->i_nlink) {
			inode->i_size = 0;
			hfsplus_file_truncate(inode);
		}
	} else if (S_ISLNK(inode->i_mode)) {
		inode->i_size = 0;
		hfsplus_file_truncate(inode);
	}
	sb->s_dirt = 1;
}

void hfsplus_inode_read_fork(struct inode *inode, struct hfsplus_fork_raw *fork)
{
	struct super_block *sb = inode->i_sb;
433
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
434
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
Linus Torvalds's avatar
Linus Torvalds committed
435
436
437
	u32 count;
	int i;

438
	memcpy(&hip->first_extents, &fork->extents, sizeof(hfsplus_extent_rec));
Linus Torvalds's avatar
Linus Torvalds committed
439
440
	for (count = 0, i = 0; i < 8; i++)
		count += be32_to_cpu(fork->extents[i].block_count);
441
442
443
444
445
446
447
448
449
450
451
	hip->first_blocks = count;
	memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec));
	hip->cached_start = 0;
	hip->cached_blocks = 0;

	hip->alloc_blocks = be32_to_cpu(fork->total_blocks);
	hip->phys_size = inode->i_size = be64_to_cpu(fork->total_size);
	hip->fs_blocks =
		(inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
	inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits);
	hip->clump_blocks =
452
		be32_to_cpu(fork->clump_size) >> sbi->alloc_blksz_shift;
453
454
	if (!hip->clump_blocks) {
		hip->clump_blocks = HFSPLUS_IS_RSRC(inode) ?
455
456
457
			sbi->rsrc_clump_blocks :
			sbi->data_clump_blocks;
	}
Linus Torvalds's avatar
Linus Torvalds committed
458
459
460
461
}

void hfsplus_inode_write_fork(struct inode *inode, struct hfsplus_fork_raw *fork)
{
462
	memcpy(&fork->extents, &HFSPLUS_I(inode)->first_extents,
Linus Torvalds's avatar
Linus Torvalds committed
463
464
	       sizeof(hfsplus_extent_rec));
	fork->total_size = cpu_to_be64(inode->i_size);
465
	fork->total_blocks = cpu_to_be32(HFSPLUS_I(inode)->alloc_blocks);
Linus Torvalds's avatar
Linus Torvalds committed
466
467
468
469
470
471
472
473
474
475
}

int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
{
	hfsplus_cat_entry entry;
	int res = 0;
	u16 type;

	type = hfs_bnode_read_u16(fd->bnode, fd->entryoffset);

476
	HFSPLUS_I(inode)->linkid = 0;
Linus Torvalds's avatar
Linus Torvalds committed
477
478
479
480
481
482
483
484
485
486
487
488
	if (type == HFSPLUS_FOLDER) {
		struct hfsplus_cat_folder *folder = &entry.folder;

		if (fd->entrylength < sizeof(struct hfsplus_cat_folder))
			/* panic? */;
		hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
					sizeof(struct hfsplus_cat_folder));
		hfsplus_get_perms(inode, &folder->permissions, 1);
		inode->i_nlink = 1;
		inode->i_size = 2 + be32_to_cpu(folder->valence);
		inode->i_atime = hfsp_mt2ut(folder->access_date);
		inode->i_mtime = hfsp_mt2ut(folder->content_mod_date);
Roman Zippel's avatar
Roman Zippel committed
489
		inode->i_ctime = hfsp_mt2ut(folder->attribute_mod_date);
490
491
		HFSPLUS_I(inode)->create_date = folder->create_date;
		HFSPLUS_I(inode)->fs_blocks = 0;
Linus Torvalds's avatar
Linus Torvalds committed
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
		inode->i_op = &hfsplus_dir_inode_operations;
		inode->i_fop = &hfsplus_dir_operations;
	} else if (type == HFSPLUS_FILE) {
		struct hfsplus_cat_file *file = &entry.file;

		if (fd->entrylength < sizeof(struct hfsplus_cat_file))
			/* panic? */;
		hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
					sizeof(struct hfsplus_cat_file));

		hfsplus_inode_read_fork(inode, HFSPLUS_IS_DATA(inode) ?
					&file->data_fork : &file->rsrc_fork);
		hfsplus_get_perms(inode, &file->permissions, 0);
		inode->i_nlink = 1;
		if (S_ISREG(inode->i_mode)) {
			if (file->permissions.dev)
				inode->i_nlink = be32_to_cpu(file->permissions.dev);
			inode->i_op = &hfsplus_file_inode_operations;
			inode->i_fop = &hfsplus_file_operations;
			inode->i_mapping->a_ops = &hfsplus_aops;
		} else if (S_ISLNK(inode->i_mode)) {
			inode->i_op = &page_symlink_inode_operations;
			inode->i_mapping->a_ops = &hfsplus_aops;
		} else {
			init_special_inode(inode, inode->i_mode,
					   be32_to_cpu(file->permissions.dev));
		}
		inode->i_atime = hfsp_mt2ut(file->access_date);
		inode->i_mtime = hfsp_mt2ut(file->content_mod_date);
Roman Zippel's avatar
Roman Zippel committed
521
		inode->i_ctime = hfsp_mt2ut(file->attribute_mod_date);
522
		HFSPLUS_I(inode)->create_date = file->create_date;
Linus Torvalds's avatar
Linus Torvalds committed
523
	} else {
524
		printk(KERN_ERR "hfs: bad catalog entry used to create inode\n");
Linus Torvalds's avatar
Linus Torvalds committed
525
526
527
528
529
530
531
532
533
534
535
536
		res = -EIO;
	}
	return res;
}

int hfsplus_cat_write_inode(struct inode *inode)
{
	struct inode *main_inode = inode;
	struct hfs_find_data fd;
	hfsplus_cat_entry entry;

	if (HFSPLUS_IS_RSRC(inode))
537
		main_inode = HFSPLUS_I(inode)->rsrc_inode;
Linus Torvalds's avatar
Linus Torvalds committed
538
539
540
541

	if (!main_inode->i_nlink)
		return 0;

542
	if (hfs_find_init(HFSPLUS_SB(main_inode->i_sb)->cat_tree, &fd))
Linus Torvalds's avatar
Linus Torvalds committed
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
		/* panic? */
		return -EIO;

	if (hfsplus_find_cat(main_inode->i_sb, main_inode->i_ino, &fd))
		/* panic? */
		goto out;

	if (S_ISDIR(main_inode->i_mode)) {
		struct hfsplus_cat_folder *folder = &entry.folder;

		if (fd.entrylength < sizeof(struct hfsplus_cat_folder))
			/* panic? */;
		hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
					sizeof(struct hfsplus_cat_folder));
		/* simple node checks? */
558
		hfsplus_cat_set_perms(inode, &folder->permissions);
Linus Torvalds's avatar
Linus Torvalds committed
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
		folder->access_date = hfsp_ut2mt(inode->i_atime);
		folder->content_mod_date = hfsp_ut2mt(inode->i_mtime);
		folder->attribute_mod_date = hfsp_ut2mt(inode->i_ctime);
		folder->valence = cpu_to_be32(inode->i_size - 2);
		hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
					 sizeof(struct hfsplus_cat_folder));
	} else if (HFSPLUS_IS_RSRC(inode)) {
		struct hfsplus_cat_file *file = &entry.file;
		hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
			       sizeof(struct hfsplus_cat_file));
		hfsplus_inode_write_fork(inode, &file->rsrc_fork);
		hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
				sizeof(struct hfsplus_cat_file));
	} else {
		struct hfsplus_cat_file *file = &entry.file;

		if (fd.entrylength < sizeof(struct hfsplus_cat_file))
			/* panic? */;
		hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
					sizeof(struct hfsplus_cat_file));
		hfsplus_inode_write_fork(inode, &file->data_fork);
580
		hfsplus_cat_set_perms(inode, &file->permissions);
Linus Torvalds's avatar
Linus Torvalds committed
581
582
583
584
585
586
587
588
589
590
591
592
593
594
		if ((file->permissions.rootflags | file->permissions.userflags) & HFSPLUS_FLG_IMMUTABLE)
			file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED);
		else
			file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED);
		file->access_date = hfsp_ut2mt(inode->i_atime);
		file->content_mod_date = hfsp_ut2mt(inode->i_mtime);
		file->attribute_mod_date = hfsp_ut2mt(inode->i_ctime);
		hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
					 sizeof(struct hfsplus_cat_file));
	}
out:
	hfs_find_exit(&fd);
	return 0;
}