inode.c 10.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
/*
 *  linux/fs/affs/inode.c
 *
 *  (c) 1996  Hans-Joachim Widmaier - Rewritten
 *
 *  (C) 1993  Ray Burr - Modified for Amiga FFS filesystem.
 *
 *  (C) 1992  Eric Youngdale Modified for ISO9660 filesystem.
 *
 *  (C) 1991  Linus Torvalds - minix filesystem
 */
Alexey Dobriyan's avatar
Alexey Dobriyan committed
12
#include <linux/sched.h>
13
#include <linux/gfp.h>
Linus Torvalds's avatar
Linus Torvalds committed
14
15
#include "affs.h"

16
struct inode *affs_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds's avatar
Linus Torvalds committed
17
18
19
20
{
	struct affs_sb_info	*sbi = AFFS_SB(sb);
	struct buffer_head	*bh;
	struct affs_tail	*tail;
21
	struct inode		*inode;
Linus Torvalds's avatar
Linus Torvalds committed
22
23
24
25
26
	u32			 block;
	u32			 size;
	u32			 prot;
	u16			 id;

27
28
29
30
31
32
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

Fabian Frederick's avatar
Fabian Frederick committed
33
	pr_debug("affs_iget(%lu)\n", inode->i_ino);
Linus Torvalds's avatar
Linus Torvalds committed
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

	block = inode->i_ino;
	bh = affs_bread(sb, block);
	if (!bh) {
		affs_warning(sb, "read_inode", "Cannot read block %d", block);
		goto bad_inode;
	}
	if (affs_checksum_block(sb, bh) || be32_to_cpu(AFFS_HEAD(bh)->ptype) != T_SHORT) {
		affs_warning(sb,"read_inode",
			   "Checksum or type (ptype=%d) error on inode %d",
			   AFFS_HEAD(bh)->ptype, block);
		goto bad_inode;
	}

	tail = AFFS_TAIL(sb, bh);
	prot = be32_to_cpu(tail->protect);

	inode->i_size = 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
52
	set_nlink(inode, 1);
Linus Torvalds's avatar
Linus Torvalds committed
53
54
55
56
	inode->i_mode = 0;
	AFFS_I(inode)->i_extcnt = 1;
	AFFS_I(inode)->i_ext_last = ~1;
	AFFS_I(inode)->i_protect = prot;
57
	atomic_set(&AFFS_I(inode)->i_opencnt, 0);
Linus Torvalds's avatar
Linus Torvalds committed
58
59
60
61
62
63
64
65
66
67
68
	AFFS_I(inode)->i_blkcnt = 0;
	AFFS_I(inode)->i_lc = NULL;
	AFFS_I(inode)->i_lc_size = 0;
	AFFS_I(inode)->i_lc_shift = 0;
	AFFS_I(inode)->i_lc_mask = 0;
	AFFS_I(inode)->i_ac = NULL;
	AFFS_I(inode)->i_ext_bh = NULL;
	AFFS_I(inode)->mmu_private = 0;
	AFFS_I(inode)->i_lastalloc = 0;
	AFFS_I(inode)->i_pa_cnt = 0;

69
	if (affs_test_opt(sbi->s_flags, SF_SETMODE))
Linus Torvalds's avatar
Linus Torvalds committed
70
71
72
73
74
		inode->i_mode = sbi->s_mode;
	else
		inode->i_mode = prot_to_mode(prot);

	id = be16_to_cpu(tail->uid);
75
	if (id == 0 || affs_test_opt(sbi->s_flags, SF_SETUID))
Linus Torvalds's avatar
Linus Torvalds committed
76
		inode->i_uid = sbi->s_uid;
77
	else if (id == 0xFFFF && affs_test_opt(sbi->s_flags, SF_MUFS))
78
		i_uid_write(inode, 0);
Linus Torvalds's avatar
Linus Torvalds committed
79
	else
80
		i_uid_write(inode, id);
Linus Torvalds's avatar
Linus Torvalds committed
81
82

	id = be16_to_cpu(tail->gid);
83
	if (id == 0 || affs_test_opt(sbi->s_flags, SF_SETGID))
Linus Torvalds's avatar
Linus Torvalds committed
84
		inode->i_gid = sbi->s_gid;
85
	else if (id == 0xFFFF && affs_test_opt(sbi->s_flags, SF_MUFS))
86
		i_gid_write(inode, 0);
Linus Torvalds's avatar
Linus Torvalds committed
87
	else
88
		i_gid_write(inode, id);
Linus Torvalds's avatar
Linus Torvalds committed
89
90
91
92
93
94
95
96

	switch (be32_to_cpu(tail->stype)) {
	case ST_ROOT:
		inode->i_uid = sbi->s_uid;
		inode->i_gid = sbi->s_gid;
		/* fall through */
	case ST_USERDIR:
		if (be32_to_cpu(tail->stype) == ST_USERDIR ||
97
		    affs_test_opt(sbi->s_flags, SF_SETMODE)) {
Linus Torvalds's avatar
Linus Torvalds committed
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
			if (inode->i_mode & S_IRUSR)
				inode->i_mode |= S_IXUSR;
			if (inode->i_mode & S_IRGRP)
				inode->i_mode |= S_IXGRP;
			if (inode->i_mode & S_IROTH)
				inode->i_mode |= S_IXOTH;
			inode->i_mode |= S_IFDIR;
		} else
			inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR;
		/* Maybe it should be controlled by mount parameter? */
		//inode->i_mode |= S_ISVTX;
		inode->i_op = &affs_dir_inode_operations;
		inode->i_fop = &affs_dir_operations;
		break;
	case ST_LINKDIR:
#if 0
		affs_warning(sb, "read_inode", "inode is LINKDIR");
		goto bad_inode;
#else
		inode->i_mode |= S_IFDIR;
Al Viro's avatar
Al Viro committed
118
		/* ... and leave ->i_op and ->i_fop pointing to empty */
Linus Torvalds's avatar
Linus Torvalds committed
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
		break;
#endif
	case ST_LINKFILE:
		affs_warning(sb, "read_inode", "inode is LINKFILE");
		goto bad_inode;
	case ST_FILE:
		size = be32_to_cpu(tail->size);
		inode->i_mode |= S_IFREG;
		AFFS_I(inode)->mmu_private = inode->i_size = size;
		if (inode->i_size) {
			AFFS_I(inode)->i_blkcnt = (size - 1) /
					       sbi->s_data_blksize + 1;
			AFFS_I(inode)->i_extcnt = (AFFS_I(inode)->i_blkcnt - 1) /
					       sbi->s_hashsize + 1;
		}
		if (tail->link_chain)
Miklos Szeredi's avatar
Miklos Szeredi committed
135
			set_nlink(inode, 2);
136
		inode->i_mapping->a_ops = affs_test_opt(sbi->s_flags, SF_OFS) ?
137
					  &affs_aops_ofs : &affs_aops;
Linus Torvalds's avatar
Linus Torvalds committed
138
139
140
141
142
		inode->i_op = &affs_file_inode_operations;
		inode->i_fop = &affs_file_operations;
		break;
	case ST_SOFTLINK:
		inode->i_mode |= S_IFLNK;
143
		inode_nohighmem(inode);
Linus Torvalds's avatar
Linus Torvalds committed
144
145
146
147
148
149
150
151
152
153
154
155
156
		inode->i_op = &affs_symlink_inode_operations;
		inode->i_data.a_ops = &affs_symlink_aops;
		break;
	}

	inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec
		       = (be32_to_cpu(tail->change.days) * (24 * 60 * 60) +
		         be32_to_cpu(tail->change.mins) * 60 +
			 be32_to_cpu(tail->change.ticks) / 50 +
			 ((8 * 365 + 2) * 24 * 60 * 60)) +
			 sys_tz.tz_minuteswest * 60;
	inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_atime.tv_nsec = 0;
	affs_brelse(bh);
157
158
	unlock_new_inode(inode);
	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
159
160
161

bad_inode:
	affs_brelse(bh);
162
163
	iget_failed(inode);
	return ERR_PTR(-EIO);
Linus Torvalds's avatar
Linus Torvalds committed
164
165
166
}

int
167
affs_write_inode(struct inode *inode, struct writeback_control *wbc)
Linus Torvalds's avatar
Linus Torvalds committed
168
169
170
171
172
173
174
{
	struct super_block	*sb = inode->i_sb;
	struct buffer_head	*bh;
	struct affs_tail	*tail;
	uid_t			 uid;
	gid_t			 gid;

Fabian Frederick's avatar
Fabian Frederick committed
175
	pr_debug("write_inode(%lu)\n", inode->i_ino);
Linus Torvalds's avatar
Linus Torvalds committed
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

	if (!inode->i_nlink)
		// possibly free block
		return 0;
	bh = affs_bread(sb, inode->i_ino);
	if (!bh) {
		affs_error(sb,"write_inode","Cannot read block %lu",inode->i_ino);
		return -EIO;
	}
	tail = AFFS_TAIL(sb, bh);
	if (tail->stype == cpu_to_be32(ST_ROOT)) {
		secs_to_datestamp(inode->i_mtime.tv_sec,&AFFS_ROOT_TAIL(sb, bh)->root_change);
	} else {
		tail->protect = cpu_to_be32(AFFS_I(inode)->i_protect);
		tail->size = cpu_to_be32(inode->i_size);
		secs_to_datestamp(inode->i_mtime.tv_sec,&tail->change);
		if (!(inode->i_ino == AFFS_SB(sb)->s_root_block)) {
193
194
			uid = i_uid_read(inode);
			gid = i_gid_read(inode);
195
			if (affs_test_opt(AFFS_SB(sb)->s_flags, SF_MUFS)) {
196
197
198
199
				if (uid == 0 || uid == 0xFFFF)
					uid = uid ^ ~0;
				if (gid == 0 || gid == 0xFFFF)
					gid = gid ^ ~0;
Linus Torvalds's avatar
Linus Torvalds committed
200
			}
201
			if (!affs_test_opt(AFFS_SB(sb)->s_flags, SF_SETUID))
Linus Torvalds's avatar
Linus Torvalds committed
202
				tail->uid = cpu_to_be16(uid);
203
			if (!affs_test_opt(AFFS_SB(sb)->s_flags, SF_SETGID))
Linus Torvalds's avatar
Linus Torvalds committed
204
205
206
207
208
209
210
211
212
213
214
215
216
				tail->gid = cpu_to_be16(gid);
		}
	}
	affs_fix_checksum(sb, bh);
	mark_buffer_dirty_inode(bh, inode);
	affs_brelse(bh);
	affs_free_prealloc(inode);
	return 0;
}

int
affs_notify_change(struct dentry *dentry, struct iattr *attr)
{
217
	struct inode *inode = d_inode(dentry);
Linus Torvalds's avatar
Linus Torvalds committed
218
219
	int error;

Fabian Frederick's avatar
Fabian Frederick committed
220
	pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
Linus Torvalds's avatar
Linus Torvalds committed
221

222
	error = setattr_prepare(dentry, attr);
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
	if (error)
		goto out;

226
	if (((attr->ia_valid & ATTR_UID) &&
227
	      affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_SETUID)) ||
228
	    ((attr->ia_valid & ATTR_GID) &&
229
	      affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_SETGID)) ||
Linus Torvalds's avatar
Linus Torvalds committed
230
	    ((attr->ia_valid & ATTR_MODE) &&
231
232
	     (AFFS_SB(inode->i_sb)->s_flags &
	      (AFFS_MOUNT_SF_SETMODE | AFFS_MOUNT_SF_IMMUTABLE)))) {
233
		if (!affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_QUIET))
Linus Torvalds's avatar
Linus Torvalds committed
234
235
236
237
			error = -EPERM;
		goto out;
	}

Christoph Hellwig's avatar
Christoph Hellwig committed
238
239
	if ((attr->ia_valid & ATTR_SIZE) &&
	    attr->ia_size != i_size_read(inode)) {
Marco Stornelli's avatar
Marco Stornelli committed
240
		error = inode_newsize_ok(inode, attr->ia_size);
Christoph Hellwig's avatar
Christoph Hellwig committed
241
242
		if (error)
			return error;
Marco Stornelli's avatar
Marco Stornelli committed
243
244
245

		truncate_setsize(inode, attr->ia_size);
		affs_truncate(inode);
Christoph Hellwig's avatar
Christoph Hellwig committed
246
247
248
249
250
251
	}

	setattr_copy(inode, attr);
	mark_inode_dirty(inode);

	if (attr->ia_valid & ATTR_MODE)
Linus Torvalds's avatar
Linus Torvalds committed
252
253
254
255
256
257
		mode_to_prot(inode);
out:
	return error;
}

void
Al Viro's avatar
Al Viro committed
258
affs_evict_inode(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
259
{
260
	unsigned long cache_page;
Fabian Frederick's avatar
Fabian Frederick committed
261
262
	pr_debug("evict_inode(ino=%lu, nlink=%u)\n",
		 inode->i_ino, inode->i_nlink);
263
	truncate_inode_pages_final(&inode->i_data);
Linus Torvalds's avatar
Linus Torvalds committed
264

Al Viro's avatar
Al Viro committed
265
266
267
268
	if (!inode->i_nlink) {
		inode->i_size = 0;
		affs_truncate(inode);
	}
269

Al Viro's avatar
Al Viro committed
270
	invalidate_inode_buffers(inode);
271
	clear_inode(inode);
272
273
	affs_free_prealloc(inode);
	cache_page = (unsigned long)AFFS_I(inode)->i_lc;
Linus Torvalds's avatar
Linus Torvalds committed
274
	if (cache_page) {
Fabian Frederick's avatar
Fabian Frederick committed
275
		pr_debug("freeing ext cache\n");
Linus Torvalds's avatar
Linus Torvalds committed
276
277
278
279
280
281
282
		AFFS_I(inode)->i_lc = NULL;
		AFFS_I(inode)->i_ac = NULL;
		free_page(cache_page);
	}
	affs_brelse(AFFS_I(inode)->i_ext_bh);
	AFFS_I(inode)->i_ext_last = ~1;
	AFFS_I(inode)->i_ext_bh = NULL;
Al Viro's avatar
Al Viro committed
283
284
285

	if (!inode->i_nlink)
		affs_free_block(inode->i_sb, inode->i_ino);
Linus Torvalds's avatar
Linus Torvalds committed
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
}

struct inode *
affs_new_inode(struct inode *dir)
{
	struct super_block	*sb = dir->i_sb;
	struct inode		*inode;
	u32			 block;
	struct buffer_head	*bh;

	if (!(inode = new_inode(sb)))
		goto err_inode;

	if (!(block = affs_alloc_block(dir, dir->i_ino)))
		goto err_block;

	bh = affs_getzeroblk(sb, block);
	if (!bh)
		goto err_bh;
	mark_buffer_dirty_inode(bh, inode);
	affs_brelse(bh);

308
309
	inode->i_uid     = current_fsuid();
	inode->i_gid     = current_fsgid();
Linus Torvalds's avatar
Linus Torvalds committed
310
	inode->i_ino     = block;
Miklos Szeredi's avatar
Miklos Szeredi committed
311
	set_nlink(inode, 1);
Linus Torvalds's avatar
Linus Torvalds committed
312
	inode->i_mtime   = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
313
	atomic_set(&AFFS_I(inode)->i_opencnt, 0);
Linus Torvalds's avatar
Linus Torvalds committed
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
	AFFS_I(inode)->i_blkcnt = 0;
	AFFS_I(inode)->i_lc = NULL;
	AFFS_I(inode)->i_lc_size = 0;
	AFFS_I(inode)->i_lc_shift = 0;
	AFFS_I(inode)->i_lc_mask = 0;
	AFFS_I(inode)->i_ac = NULL;
	AFFS_I(inode)->i_ext_bh = NULL;
	AFFS_I(inode)->mmu_private = 0;
	AFFS_I(inode)->i_protect = 0;
	AFFS_I(inode)->i_lastalloc = 0;
	AFFS_I(inode)->i_pa_cnt = 0;
	AFFS_I(inode)->i_extcnt = 1;
	AFFS_I(inode)->i_ext_last = ~1;

	insert_inode_hash(inode);

	return inode;

err_bh:
	affs_free_block(sb, block);
err_block:
	iput(inode);
err_inode:
	return NULL;
}

/*
 * Add an entry to a directory. Create the header block
 * and insert it into the hash table.
 */

int
affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s32 type)
{
	struct super_block *sb = dir->i_sb;
	struct buffer_head *inode_bh = NULL;
350
	struct buffer_head *bh;
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
	u32 block = 0;
	int retval;

354
355
	pr_debug("%s(dir=%lu, inode=%lu, \"%pd\", type=%d)\n", __func__,
		 dir->i_ino, inode->i_ino, dentry, type);
Linus Torvalds's avatar
Linus Torvalds committed
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370

	retval = -EIO;
	bh = affs_bread(sb, inode->i_ino);
	if (!bh)
		goto done;

	affs_lock_link(inode);
	switch (type) {
	case ST_LINKFILE:
	case ST_LINKDIR:
		retval = -ENOSPC;
		block = affs_alloc_block(dir, dir->i_ino);
		if (!block)
			goto err;
		retval = -EIO;
371
		inode_bh = bh;
Linus Torvalds's avatar
Linus Torvalds committed
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
		bh = affs_getzeroblk(sb, block);
		if (!bh)
			goto err;
		break;
	default:
		break;
	}

	AFFS_HEAD(bh)->ptype = cpu_to_be32(T_SHORT);
	AFFS_HEAD(bh)->key = cpu_to_be32(bh->b_blocknr);
	affs_copy_name(AFFS_TAIL(sb, bh)->name, dentry);
	AFFS_TAIL(sb, bh)->stype = cpu_to_be32(type);
	AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino);

	if (inode_bh) {
		__be32 chain;
	       	chain = AFFS_TAIL(sb, inode_bh)->link_chain;
		AFFS_TAIL(sb, bh)->original = cpu_to_be32(inode->i_ino);
		AFFS_TAIL(sb, bh)->link_chain = chain;
		AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block);
		affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain));
		mark_buffer_dirty_inode(inode_bh, inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
394
		set_nlink(inode, 2);
Al Viro's avatar
Al Viro committed
395
		ihold(inode);
Linus Torvalds's avatar
Linus Torvalds committed
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
	}
	affs_fix_checksum(sb, bh);
	mark_buffer_dirty_inode(bh, inode);
	dentry->d_fsdata = (void *)(long)bh->b_blocknr;

	affs_lock_dir(dir);
	retval = affs_insert_hash(dir, bh);
	mark_buffer_dirty_inode(bh, inode);
	affs_unlock_dir(dir);
	affs_unlock_link(inode);

	d_instantiate(dentry, inode);
done:
	affs_brelse(inode_bh);
	affs_brelse(bh);
	return retval;
err:
	if (block)
		affs_free_block(sb, block);
	affs_unlock_link(inode);
	goto done;
}