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 <asm/byteorder.h>
33 /* This is only called on sync() and umount(), when s_dirt=1. */
34 static void sysv_write_super(struct super_block
*sb
)
36 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
37 unsigned long time
= get_seconds(), old_time
;
40 if (sb
->s_flags
& MS_RDONLY
)
44 * If we are going to write out the super block,
45 * then attach current time stamp.
46 * But if the filesystem was marked clean, keep it clean.
48 old_time
= fs32_to_cpu(sbi
, *sbi
->s_sb_time
);
49 if (sbi
->s_type
== FSTYPE_SYSV4
) {
50 if (*sbi
->s_sb_state
== cpu_to_fs32(sbi
, 0x7c269d38 - old_time
))
51 *sbi
->s_sb_state
= cpu_to_fs32(sbi
, 0x7c269d38 - time
);
52 *sbi
->s_sb_time
= cpu_to_fs32(sbi
, time
);
53 mark_buffer_dirty(sbi
->s_bh2
);
60 static int sysv_remount(struct super_block
*sb
, int *flags
, char *data
)
62 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
65 if (!(*flags
& MS_RDONLY
))
70 static void sysv_put_super(struct super_block
*sb
)
72 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
74 if (!(sb
->s_flags
& MS_RDONLY
)) {
75 /* XXX ext2 also updates the state here */
76 mark_buffer_dirty(sbi
->s_bh1
);
77 if (sbi
->s_bh1
!= sbi
->s_bh2
)
78 mark_buffer_dirty(sbi
->s_bh2
);
82 if (sbi
->s_bh1
!= sbi
->s_bh2
)
88 static int sysv_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
90 struct super_block
*sb
= dentry
->d_sb
;
91 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
93 buf
->f_type
= sb
->s_magic
;
94 buf
->f_bsize
= sb
->s_blocksize
;
95 buf
->f_blocks
= sbi
->s_ndatazones
;
96 buf
->f_bavail
= buf
->f_bfree
= sysv_count_free_blocks(sb
);
97 buf
->f_files
= sbi
->s_ninodes
;
98 buf
->f_ffree
= sysv_count_free_inodes(sb
);
99 buf
->f_namelen
= SYSV_NAMELEN
;
104 * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32
106 static inline void read3byte(struct sysv_sb_info
*sbi
,
107 unsigned char * from
, unsigned char * to
)
109 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
114 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
127 static inline void write3byte(struct sysv_sb_info
*sbi
,
128 unsigned char * from
, unsigned char * to
)
130 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
134 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
145 static const struct inode_operations sysv_symlink_inode_operations
= {
146 .readlink
= generic_readlink
,
147 .follow_link
= page_follow_link_light
,
148 .put_link
= page_put_link
,
149 .getattr
= sysv_getattr
,
152 void sysv_set_inode(struct inode
*inode
, dev_t rdev
)
154 if (S_ISREG(inode
->i_mode
)) {
155 inode
->i_op
= &sysv_file_inode_operations
;
156 inode
->i_fop
= &sysv_file_operations
;
157 inode
->i_mapping
->a_ops
= &sysv_aops
;
158 } else if (S_ISDIR(inode
->i_mode
)) {
159 inode
->i_op
= &sysv_dir_inode_operations
;
160 inode
->i_fop
= &sysv_dir_operations
;
161 inode
->i_mapping
->a_ops
= &sysv_aops
;
162 } else if (S_ISLNK(inode
->i_mode
)) {
163 if (inode
->i_blocks
) {
164 inode
->i_op
= &sysv_symlink_inode_operations
;
165 inode
->i_mapping
->a_ops
= &sysv_aops
;
167 inode
->i_op
= &sysv_fast_symlink_inode_operations
;
169 init_special_inode(inode
, inode
->i_mode
, rdev
);
172 static void sysv_read_inode(struct inode
*inode
)
174 struct super_block
* sb
= inode
->i_sb
;
175 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
176 struct buffer_head
* bh
;
177 struct sysv_inode
* raw_inode
;
178 struct sysv_inode_info
* si
;
179 unsigned int block
, ino
= inode
->i_ino
;
181 if (!ino
|| ino
> sbi
->s_ninodes
) {
182 printk("Bad inode number on dev %s: %d is out of range\n",
183 inode
->i_sb
->s_id
, ino
);
186 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
188 printk("Major problem: unable to read inode from dev %s\n",
192 /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
193 inode
->i_mode
= fs16_to_cpu(sbi
, raw_inode
->i_mode
);
194 inode
->i_uid
= (uid_t
)fs16_to_cpu(sbi
, raw_inode
->i_uid
);
195 inode
->i_gid
= (gid_t
)fs16_to_cpu(sbi
, raw_inode
->i_gid
);
196 inode
->i_nlink
= fs16_to_cpu(sbi
, raw_inode
->i_nlink
);
197 inode
->i_size
= fs32_to_cpu(sbi
, raw_inode
->i_size
);
198 inode
->i_atime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_atime
);
199 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_mtime
);
200 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_ctime
);
201 inode
->i_ctime
.tv_nsec
= 0;
202 inode
->i_atime
.tv_nsec
= 0;
203 inode
->i_mtime
.tv_nsec
= 0;
207 for (block
= 0; block
< 10+1+1+1; block
++)
208 read3byte(sbi
, &raw_inode
->i_data
[3*block
],
209 (u8
*)&si
->i_data
[block
]);
211 si
->i_dir_start_lookup
= 0;
212 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
213 sysv_set_inode(inode
,
214 old_decode_dev(fs32_to_cpu(sbi
, si
->i_data
[0])));
216 sysv_set_inode(inode
, 0);
220 make_bad_inode(inode
);
224 static struct buffer_head
* sysv_update_inode(struct inode
* inode
)
226 struct super_block
* sb
= inode
->i_sb
;
227 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
228 struct buffer_head
* bh
;
229 struct sysv_inode
* raw_inode
;
230 struct sysv_inode_info
* si
;
231 unsigned int ino
, block
;
234 if (!ino
|| ino
> sbi
->s_ninodes
) {
235 printk("Bad inode number on dev %s: %d is out of range\n",
236 inode
->i_sb
->s_id
, ino
);
239 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
241 printk("unable to read i-node block\n");
245 raw_inode
->i_mode
= cpu_to_fs16(sbi
, inode
->i_mode
);
246 raw_inode
->i_uid
= cpu_to_fs16(sbi
, fs_high2lowuid(inode
->i_uid
));
247 raw_inode
->i_gid
= cpu_to_fs16(sbi
, fs_high2lowgid(inode
->i_gid
));
248 raw_inode
->i_nlink
= cpu_to_fs16(sbi
, inode
->i_nlink
);
249 raw_inode
->i_size
= cpu_to_fs32(sbi
, inode
->i_size
);
250 raw_inode
->i_atime
= cpu_to_fs32(sbi
, inode
->i_atime
.tv_sec
);
251 raw_inode
->i_mtime
= cpu_to_fs32(sbi
, inode
->i_mtime
.tv_sec
);
252 raw_inode
->i_ctime
= cpu_to_fs32(sbi
, inode
->i_ctime
.tv_sec
);
255 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
256 si
->i_data
[0] = cpu_to_fs32(sbi
, old_encode_dev(inode
->i_rdev
));
257 for (block
= 0; block
< 10+1+1+1; block
++)
258 write3byte(sbi
, (u8
*)&si
->i_data
[block
],
259 &raw_inode
->i_data
[3*block
]);
260 mark_buffer_dirty(bh
);
264 int sysv_write_inode(struct inode
* inode
, int wait
)
266 struct buffer_head
*bh
;
268 bh
= sysv_update_inode(inode
);
274 int sysv_sync_inode(struct inode
* inode
)
277 struct buffer_head
*bh
;
279 bh
= sysv_update_inode(inode
);
280 if (bh
&& buffer_dirty(bh
)) {
281 sync_dirty_buffer(bh
);
282 if (buffer_req(bh
) && !buffer_uptodate(bh
)) {
283 printk ("IO error syncing sysv inode [%s:%08lx]\n",
284 inode
->i_sb
->s_id
, inode
->i_ino
);
294 static void sysv_delete_inode(struct inode
*inode
)
296 truncate_inode_pages(&inode
->i_data
, 0);
298 sysv_truncate(inode
);
300 sysv_free_inode(inode
);
304 static struct kmem_cache
*sysv_inode_cachep
;
306 static struct inode
*sysv_alloc_inode(struct super_block
*sb
)
308 struct sysv_inode_info
*si
;
310 si
= kmem_cache_alloc(sysv_inode_cachep
, GFP_KERNEL
);
313 return &si
->vfs_inode
;
316 static void sysv_destroy_inode(struct inode
*inode
)
318 kmem_cache_free(sysv_inode_cachep
, SYSV_I(inode
));
321 static void init_once(void *p
, struct kmem_cache
*cachep
, unsigned long flags
)
323 struct sysv_inode_info
*si
= (struct sysv_inode_info
*)p
;
325 inode_init_once(&si
->vfs_inode
);
328 const struct super_operations sysv_sops
= {
329 .alloc_inode
= sysv_alloc_inode
,
330 .destroy_inode
= sysv_destroy_inode
,
331 .read_inode
= sysv_read_inode
,
332 .write_inode
= sysv_write_inode
,
333 .delete_inode
= sysv_delete_inode
,
334 .put_super
= sysv_put_super
,
335 .write_super
= sysv_write_super
,
336 .remount_fs
= sysv_remount
,
337 .statfs
= sysv_statfs
,
340 int __init
sysv_init_icache(void)
342 sysv_inode_cachep
= kmem_cache_create("sysv_inode_cache",
343 sizeof(struct sysv_inode_info
), 0,
344 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
,
346 if (!sysv_inode_cachep
)
351 void sysv_destroy_icache(void)
353 kmem_cache_destroy(sysv_inode_cachep
);