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 <asm/byteorder.h>
32 /* This is only called on sync() and umount(), when s_dirt=1. */
33 static void sysv_write_super(struct super_block
*sb
)
35 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
36 unsigned long time
= get_seconds(), old_time
;
39 if (sb
->s_flags
& MS_RDONLY
)
43 * If we are going to write out the super block,
44 * then attach current time stamp.
45 * But if the filesystem was marked clean, keep it clean.
47 old_time
= fs32_to_cpu(sbi
, *sbi
->s_sb_time
);
48 if (sbi
->s_type
== FSTYPE_SYSV4
) {
49 if (*sbi
->s_sb_state
== cpu_to_fs32(sbi
, 0x7c269d38 - old_time
))
50 *sbi
->s_sb_state
= cpu_to_fs32(sbi
, 0x7c269d38 - time
);
51 *sbi
->s_sb_time
= cpu_to_fs32(sbi
, time
);
52 mark_buffer_dirty(sbi
->s_bh2
);
59 static void sysv_put_super(struct super_block
*sb
)
61 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
63 if (!(sb
->s_flags
& MS_RDONLY
)) {
64 /* XXX ext2 also updates the state here */
65 mark_buffer_dirty(sbi
->s_bh1
);
66 if (sbi
->s_bh1
!= sbi
->s_bh2
)
67 mark_buffer_dirty(sbi
->s_bh2
);
71 if (sbi
->s_bh1
!= sbi
->s_bh2
)
77 static int sysv_statfs(struct super_block
*sb
, struct statfs
*buf
)
79 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
81 buf
->f_type
= sb
->s_magic
;
82 buf
->f_bsize
= sb
->s_blocksize
;
83 buf
->f_blocks
= sbi
->s_ndatazones
;
84 buf
->f_bavail
= buf
->f_bfree
= sysv_count_free_blocks(sb
);
85 buf
->f_files
= sbi
->s_ninodes
;
86 buf
->f_ffree
= sysv_count_free_inodes(sb
);
87 buf
->f_namelen
= SYSV_NAMELEN
;
92 * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32
94 static inline void read3byte(struct sysv_sb_info
*sbi
,
95 unsigned char * from
, unsigned char * to
)
97 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
102 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
115 static inline void write3byte(struct sysv_sb_info
*sbi
,
116 unsigned char * from
, unsigned char * to
)
118 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
122 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
133 static struct inode_operations sysv_symlink_inode_operations
= {
134 .readlink
= page_readlink
,
135 .follow_link
= page_follow_link
,
136 .getattr
= sysv_getattr
,
139 void sysv_set_inode(struct inode
*inode
, dev_t rdev
)
141 if (S_ISREG(inode
->i_mode
)) {
142 inode
->i_op
= &sysv_file_inode_operations
;
143 inode
->i_fop
= &sysv_file_operations
;
144 inode
->i_mapping
->a_ops
= &sysv_aops
;
145 } else if (S_ISDIR(inode
->i_mode
)) {
146 inode
->i_op
= &sysv_dir_inode_operations
;
147 inode
->i_fop
= &sysv_dir_operations
;
148 inode
->i_mapping
->a_ops
= &sysv_aops
;
149 } else if (S_ISLNK(inode
->i_mode
)) {
150 if (inode
->i_blocks
) {
151 inode
->i_op
= &sysv_symlink_inode_operations
;
152 inode
->i_mapping
->a_ops
= &sysv_aops
;
154 inode
->i_op
= &sysv_fast_symlink_inode_operations
;
156 init_special_inode(inode
, inode
->i_mode
, rdev
);
159 static void sysv_read_inode(struct inode
*inode
)
161 struct super_block
* sb
= inode
->i_sb
;
162 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
163 struct buffer_head
* bh
;
164 struct sysv_inode
* raw_inode
;
165 struct sysv_inode_info
* si
;
166 unsigned int block
, ino
;
170 if (!ino
|| ino
> sbi
->s_ninodes
) {
171 printk("Bad inode number on dev %s: %d is out of range\n",
172 inode
->i_sb
->s_id
, ino
);
175 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
177 printk("Major problem: unable to read inode from dev %s\n",
181 /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
182 inode
->i_mode
= fs16_to_cpu(sbi
, raw_inode
->i_mode
);
183 inode
->i_uid
= (uid_t
)fs16_to_cpu(sbi
, raw_inode
->i_uid
);
184 inode
->i_gid
= (gid_t
)fs16_to_cpu(sbi
, raw_inode
->i_gid
);
185 inode
->i_nlink
= fs16_to_cpu(sbi
, raw_inode
->i_nlink
);
186 inode
->i_size
= fs32_to_cpu(sbi
, raw_inode
->i_size
);
187 inode
->i_atime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_atime
);
188 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_mtime
);
189 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_ctime
);
190 inode
->i_ctime
.tv_nsec
= 0;
191 inode
->i_atime
.tv_nsec
= 0;
192 inode
->i_mtime
.tv_nsec
= 0;
193 inode
->i_blocks
= inode
->i_blksize
= 0;
196 for (block
= 0; block
< 10+1+1+1; block
++)
197 read3byte(sbi
, &raw_inode
->i_data
[3*block
],
198 (u8
*)&si
->i_data
[block
]);
200 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
201 rdev
= (u16
)fs32_to_cpu(sbi
, si
->i_data
[0]);
202 si
->i_dir_start_lookup
= 0;
203 sysv_set_inode(inode
, rdev
);
207 make_bad_inode(inode
);
211 static struct buffer_head
* sysv_update_inode(struct inode
* inode
)
213 struct super_block
* sb
= inode
->i_sb
;
214 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
215 struct buffer_head
* bh
;
216 struct sysv_inode
* raw_inode
;
217 struct sysv_inode_info
* si
;
218 unsigned int ino
, block
;
221 if (!ino
|| ino
> sbi
->s_ninodes
) {
222 printk("Bad inode number on dev %s: %d is out of range\n",
223 inode
->i_sb
->s_id
, ino
);
226 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
228 printk("unable to read i-node block\n");
232 raw_inode
->i_mode
= cpu_to_fs16(sbi
, inode
->i_mode
);
233 raw_inode
->i_uid
= cpu_to_fs16(sbi
, fs_high2lowuid(inode
->i_uid
));
234 raw_inode
->i_gid
= cpu_to_fs16(sbi
, fs_high2lowgid(inode
->i_gid
));
235 raw_inode
->i_nlink
= cpu_to_fs16(sbi
, inode
->i_nlink
);
236 raw_inode
->i_size
= cpu_to_fs32(sbi
, inode
->i_size
);
237 raw_inode
->i_atime
= cpu_to_fs32(sbi
, inode
->i_atime
.tv_sec
);
238 raw_inode
->i_mtime
= cpu_to_fs32(sbi
, inode
->i_mtime
.tv_sec
);
239 raw_inode
->i_ctime
= cpu_to_fs32(sbi
, inode
->i_ctime
.tv_sec
);
242 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
243 si
->i_data
[0] = cpu_to_fs32(sbi
, kdev_t_to_nr(inode
->i_rdev
));
244 for (block
= 0; block
< 10+1+1+1; block
++)
245 write3byte(sbi
, (u8
*)&si
->i_data
[block
],
246 &raw_inode
->i_data
[3*block
]);
247 mark_buffer_dirty(bh
);
251 void sysv_write_inode(struct inode
* inode
, int wait
)
253 struct buffer_head
*bh
;
255 bh
= sysv_update_inode(inode
);
260 int sysv_sync_inode(struct inode
* inode
)
263 struct buffer_head
*bh
;
265 bh
= sysv_update_inode(inode
);
266 if (bh
&& buffer_dirty(bh
)) {
267 ll_rw_block(WRITE
, 1, &bh
);
269 if (buffer_req(bh
) && !buffer_uptodate(bh
)) {
270 printk ("IO error syncing sysv inode [%s:%08lx]\n",
271 inode
->i_sb
->s_id
, inode
->i_ino
);
281 static void sysv_delete_inode(struct inode
*inode
)
284 sysv_truncate(inode
);
286 sysv_free_inode(inode
);
290 static kmem_cache_t
*sysv_inode_cachep
;
292 static struct inode
*sysv_alloc_inode(struct super_block
*sb
)
294 struct sysv_inode_info
*si
;
296 si
= kmem_cache_alloc(sysv_inode_cachep
, SLAB_KERNEL
);
299 return &si
->vfs_inode
;
302 static void sysv_destroy_inode(struct inode
*inode
)
304 kmem_cache_free(sysv_inode_cachep
, SYSV_I(inode
));
307 static void init_once(void *p
, kmem_cache_t
*cachep
, unsigned long flags
)
309 struct sysv_inode_info
*si
= (struct sysv_inode_info
*)p
;
311 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
312 SLAB_CTOR_CONSTRUCTOR
)
313 inode_init_once(&si
->vfs_inode
);
316 struct super_operations sysv_sops
= {
317 .alloc_inode
= sysv_alloc_inode
,
318 .destroy_inode
= sysv_destroy_inode
,
319 .read_inode
= sysv_read_inode
,
320 .write_inode
= sysv_write_inode
,
321 .delete_inode
= sysv_delete_inode
,
322 .put_super
= sysv_put_super
,
323 .write_super
= sysv_write_super
,
324 .statfs
= sysv_statfs
,
327 int __init
sysv_init_icache(void)
329 sysv_inode_cachep
= kmem_cache_create("sysv_inode_cache",
330 sizeof(struct sysv_inode_info
), 0,
331 SLAB_HWCACHE_ALIGN
, init_once
, NULL
);
332 if (!sysv_inode_cachep
)
337 void sysv_destroy_icache(void)
339 kmem_cache_destroy(sysv_inode_cachep
);