2 * linux/fs/sysv/inode.c
5 * Copyright (C) 1991, 1992 Linus Torvalds
8 * Copyright (C) 1992 Doug Evans
11 * Copyright (C) 1993 Pascal Haible, Bruno Haible
14 * Copyright (C) 1993 Paul B. Monday
17 * Copyright (C) 1993 Bruno Haible
18 * Copyright (C) 1997, 1998 Krzysztof G. Baranowski
20 * This file contains code for allocating/freeing inodes and for read/writing
24 #include <linux/smp_lock.h>
25 #include <linux/highuid.h>
26 #include <linux/slab.h>
27 #include <linux/init.h>
28 #include <linux/buffer_head.h>
29 #include <linux/vfs.h>
30 #include <linux/namei.h>
31 #include <asm/byteorder.h>
34 /* This is only called on sync() and umount(), when s_dirt=1. */
35 static void sysv_write_super(struct super_block
*sb
)
37 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
38 unsigned long time
= get_seconds(), old_time
;
41 if (sb
->s_flags
& MS_RDONLY
)
45 * If we are going to write out the super block,
46 * then attach current time stamp.
47 * But if the filesystem was marked clean, keep it clean.
49 old_time
= fs32_to_cpu(sbi
, *sbi
->s_sb_time
);
50 if (sbi
->s_type
== FSTYPE_SYSV4
) {
51 if (*sbi
->s_sb_state
== cpu_to_fs32(sbi
, 0x7c269d38 - old_time
))
52 *sbi
->s_sb_state
= cpu_to_fs32(sbi
, 0x7c269d38 - time
);
53 *sbi
->s_sb_time
= cpu_to_fs32(sbi
, time
);
54 mark_buffer_dirty(sbi
->s_bh2
);
61 static int sysv_remount(struct super_block
*sb
, int *flags
, char *data
)
63 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
66 if (!(*flags
& MS_RDONLY
))
71 static void sysv_put_super(struct super_block
*sb
)
73 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
80 if (!(sb
->s_flags
& MS_RDONLY
)) {
81 /* XXX ext2 also updates the state here */
82 mark_buffer_dirty(sbi
->s_bh1
);
83 if (sbi
->s_bh1
!= sbi
->s_bh2
)
84 mark_buffer_dirty(sbi
->s_bh2
);
88 if (sbi
->s_bh1
!= sbi
->s_bh2
)
96 static int sysv_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
98 struct super_block
*sb
= dentry
->d_sb
;
99 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
100 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
102 buf
->f_type
= sb
->s_magic
;
103 buf
->f_bsize
= sb
->s_blocksize
;
104 buf
->f_blocks
= sbi
->s_ndatazones
;
105 buf
->f_bavail
= buf
->f_bfree
= sysv_count_free_blocks(sb
);
106 buf
->f_files
= sbi
->s_ninodes
;
107 buf
->f_ffree
= sysv_count_free_inodes(sb
);
108 buf
->f_namelen
= SYSV_NAMELEN
;
109 buf
->f_fsid
.val
[0] = (u32
)id
;
110 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
115 * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32
117 static inline void read3byte(struct sysv_sb_info
*sbi
,
118 unsigned char * from
, unsigned char * to
)
120 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
125 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
138 static inline void write3byte(struct sysv_sb_info
*sbi
,
139 unsigned char * from
, unsigned char * to
)
141 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
145 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
156 static const struct inode_operations sysv_symlink_inode_operations
= {
157 .readlink
= generic_readlink
,
158 .follow_link
= page_follow_link_light
,
159 .put_link
= page_put_link
,
160 .getattr
= sysv_getattr
,
163 void sysv_set_inode(struct inode
*inode
, dev_t rdev
)
165 if (S_ISREG(inode
->i_mode
)) {
166 inode
->i_op
= &sysv_file_inode_operations
;
167 inode
->i_fop
= &sysv_file_operations
;
168 inode
->i_mapping
->a_ops
= &sysv_aops
;
169 } else if (S_ISDIR(inode
->i_mode
)) {
170 inode
->i_op
= &sysv_dir_inode_operations
;
171 inode
->i_fop
= &sysv_dir_operations
;
172 inode
->i_mapping
->a_ops
= &sysv_aops
;
173 } else if (S_ISLNK(inode
->i_mode
)) {
174 if (inode
->i_blocks
) {
175 inode
->i_op
= &sysv_symlink_inode_operations
;
176 inode
->i_mapping
->a_ops
= &sysv_aops
;
178 inode
->i_op
= &sysv_fast_symlink_inode_operations
;
179 nd_terminate_link(SYSV_I(inode
)->i_data
, inode
->i_size
,
180 sizeof(SYSV_I(inode
)->i_data
) - 1);
183 init_special_inode(inode
, inode
->i_mode
, rdev
);
186 struct inode
*sysv_iget(struct super_block
*sb
, unsigned int ino
)
188 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
189 struct buffer_head
* bh
;
190 struct sysv_inode
* raw_inode
;
191 struct sysv_inode_info
* si
;
195 if (!ino
|| ino
> sbi
->s_ninodes
) {
196 printk("Bad inode number on dev %s: %d is out of range\n",
198 return ERR_PTR(-EIO
);
201 inode
= iget_locked(sb
, ino
);
203 return ERR_PTR(-ENOMEM
);
204 if (!(inode
->i_state
& I_NEW
))
207 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
209 printk("Major problem: unable to read inode from dev %s\n",
213 /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
214 inode
->i_mode
= fs16_to_cpu(sbi
, raw_inode
->i_mode
);
215 inode
->i_uid
= (uid_t
)fs16_to_cpu(sbi
, raw_inode
->i_uid
);
216 inode
->i_gid
= (gid_t
)fs16_to_cpu(sbi
, raw_inode
->i_gid
);
217 inode
->i_nlink
= fs16_to_cpu(sbi
, raw_inode
->i_nlink
);
218 inode
->i_size
= fs32_to_cpu(sbi
, raw_inode
->i_size
);
219 inode
->i_atime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_atime
);
220 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_mtime
);
221 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_ctime
);
222 inode
->i_ctime
.tv_nsec
= 0;
223 inode
->i_atime
.tv_nsec
= 0;
224 inode
->i_mtime
.tv_nsec
= 0;
228 for (block
= 0; block
< 10+1+1+1; block
++)
229 read3byte(sbi
, &raw_inode
->i_data
[3*block
],
230 (u8
*)&si
->i_data
[block
]);
232 si
->i_dir_start_lookup
= 0;
233 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
234 sysv_set_inode(inode
,
235 old_decode_dev(fs32_to_cpu(sbi
, si
->i_data
[0])));
237 sysv_set_inode(inode
, 0);
238 unlock_new_inode(inode
);
243 return ERR_PTR(-EIO
);
246 static struct buffer_head
* sysv_update_inode(struct inode
* inode
)
248 struct super_block
* sb
= inode
->i_sb
;
249 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
250 struct buffer_head
* bh
;
251 struct sysv_inode
* raw_inode
;
252 struct sysv_inode_info
* si
;
253 unsigned int ino
, block
;
256 if (!ino
|| ino
> sbi
->s_ninodes
) {
257 printk("Bad inode number on dev %s: %d is out of range\n",
258 inode
->i_sb
->s_id
, ino
);
261 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
263 printk("unable to read i-node block\n");
267 raw_inode
->i_mode
= cpu_to_fs16(sbi
, inode
->i_mode
);
268 raw_inode
->i_uid
= cpu_to_fs16(sbi
, fs_high2lowuid(inode
->i_uid
));
269 raw_inode
->i_gid
= cpu_to_fs16(sbi
, fs_high2lowgid(inode
->i_gid
));
270 raw_inode
->i_nlink
= cpu_to_fs16(sbi
, inode
->i_nlink
);
271 raw_inode
->i_size
= cpu_to_fs32(sbi
, inode
->i_size
);
272 raw_inode
->i_atime
= cpu_to_fs32(sbi
, inode
->i_atime
.tv_sec
);
273 raw_inode
->i_mtime
= cpu_to_fs32(sbi
, inode
->i_mtime
.tv_sec
);
274 raw_inode
->i_ctime
= cpu_to_fs32(sbi
, inode
->i_ctime
.tv_sec
);
277 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
278 si
->i_data
[0] = cpu_to_fs32(sbi
, old_encode_dev(inode
->i_rdev
));
279 for (block
= 0; block
< 10+1+1+1; block
++)
280 write3byte(sbi
, (u8
*)&si
->i_data
[block
],
281 &raw_inode
->i_data
[3*block
]);
282 mark_buffer_dirty(bh
);
286 int sysv_write_inode(struct inode
* inode
, int wait
)
288 struct buffer_head
*bh
;
290 bh
= sysv_update_inode(inode
);
296 int sysv_sync_inode(struct inode
* inode
)
299 struct buffer_head
*bh
;
301 bh
= sysv_update_inode(inode
);
302 if (bh
&& buffer_dirty(bh
)) {
303 sync_dirty_buffer(bh
);
304 if (buffer_req(bh
) && !buffer_uptodate(bh
)) {
305 printk ("IO error syncing sysv inode [%s:%08lx]\n",
306 inode
->i_sb
->s_id
, inode
->i_ino
);
316 static void sysv_delete_inode(struct inode
*inode
)
318 truncate_inode_pages(&inode
->i_data
, 0);
320 sysv_truncate(inode
);
322 sysv_free_inode(inode
);
326 static struct kmem_cache
*sysv_inode_cachep
;
328 static struct inode
*sysv_alloc_inode(struct super_block
*sb
)
330 struct sysv_inode_info
*si
;
332 si
= kmem_cache_alloc(sysv_inode_cachep
, GFP_KERNEL
);
335 return &si
->vfs_inode
;
338 static void sysv_destroy_inode(struct inode
*inode
)
340 kmem_cache_free(sysv_inode_cachep
, SYSV_I(inode
));
343 static void init_once(void *p
)
345 struct sysv_inode_info
*si
= (struct sysv_inode_info
*)p
;
347 inode_init_once(&si
->vfs_inode
);
350 const struct super_operations sysv_sops
= {
351 .alloc_inode
= sysv_alloc_inode
,
352 .destroy_inode
= sysv_destroy_inode
,
353 .write_inode
= sysv_write_inode
,
354 .delete_inode
= sysv_delete_inode
,
355 .put_super
= sysv_put_super
,
356 .write_super
= sysv_write_super
,
357 .remount_fs
= sysv_remount
,
358 .statfs
= sysv_statfs
,
361 int __init
sysv_init_icache(void)
363 sysv_inode_cachep
= kmem_cache_create("sysv_inode_cache",
364 sizeof(struct sysv_inode_info
), 0,
365 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
,
367 if (!sysv_inode_cachep
)
372 void sysv_destroy_icache(void)
374 kmem_cache_destroy(sysv_inode_cachep
);