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 static int sysv_sync_fs(struct super_block
*sb
, int wait
)
36 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
37 unsigned long time
= get_seconds(), old_time
;
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
);
61 static void sysv_write_super(struct super_block
*sb
)
63 if (!(sb
->s_flags
& MS_RDONLY
))
69 static int sysv_remount(struct super_block
*sb
, int *flags
, char *data
)
71 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
75 if (!(*flags
& MS_RDONLY
))
81 static void sysv_put_super(struct super_block
*sb
)
83 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
90 if (!(sb
->s_flags
& MS_RDONLY
)) {
91 /* XXX ext2 also updates the state here */
92 mark_buffer_dirty(sbi
->s_bh1
);
93 if (sbi
->s_bh1
!= sbi
->s_bh2
)
94 mark_buffer_dirty(sbi
->s_bh2
);
98 if (sbi
->s_bh1
!= sbi
->s_bh2
)
106 static int sysv_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
108 struct super_block
*sb
= dentry
->d_sb
;
109 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
110 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
112 buf
->f_type
= sb
->s_magic
;
113 buf
->f_bsize
= sb
->s_blocksize
;
114 buf
->f_blocks
= sbi
->s_ndatazones
;
115 buf
->f_bavail
= buf
->f_bfree
= sysv_count_free_blocks(sb
);
116 buf
->f_files
= sbi
->s_ninodes
;
117 buf
->f_ffree
= sysv_count_free_inodes(sb
);
118 buf
->f_namelen
= SYSV_NAMELEN
;
119 buf
->f_fsid
.val
[0] = (u32
)id
;
120 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
125 * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32
127 static inline void read3byte(struct sysv_sb_info
*sbi
,
128 unsigned char * from
, unsigned char * to
)
130 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
135 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
148 static inline void write3byte(struct sysv_sb_info
*sbi
,
149 unsigned char * from
, unsigned char * to
)
151 if (sbi
->s_bytesex
== BYTESEX_PDP
) {
155 } else if (sbi
->s_bytesex
== BYTESEX_LE
) {
166 static const struct inode_operations sysv_symlink_inode_operations
= {
167 .readlink
= generic_readlink
,
168 .follow_link
= page_follow_link_light
,
169 .put_link
= page_put_link
,
170 .getattr
= sysv_getattr
,
173 void sysv_set_inode(struct inode
*inode
, dev_t rdev
)
175 if (S_ISREG(inode
->i_mode
)) {
176 inode
->i_op
= &sysv_file_inode_operations
;
177 inode
->i_fop
= &sysv_file_operations
;
178 inode
->i_mapping
->a_ops
= &sysv_aops
;
179 } else if (S_ISDIR(inode
->i_mode
)) {
180 inode
->i_op
= &sysv_dir_inode_operations
;
181 inode
->i_fop
= &sysv_dir_operations
;
182 inode
->i_mapping
->a_ops
= &sysv_aops
;
183 } else if (S_ISLNK(inode
->i_mode
)) {
184 if (inode
->i_blocks
) {
185 inode
->i_op
= &sysv_symlink_inode_operations
;
186 inode
->i_mapping
->a_ops
= &sysv_aops
;
188 inode
->i_op
= &sysv_fast_symlink_inode_operations
;
189 nd_terminate_link(SYSV_I(inode
)->i_data
, inode
->i_size
,
190 sizeof(SYSV_I(inode
)->i_data
) - 1);
193 init_special_inode(inode
, inode
->i_mode
, rdev
);
196 struct inode
*sysv_iget(struct super_block
*sb
, unsigned int ino
)
198 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
199 struct buffer_head
* bh
;
200 struct sysv_inode
* raw_inode
;
201 struct sysv_inode_info
* si
;
205 if (!ino
|| ino
> sbi
->s_ninodes
) {
206 printk("Bad inode number on dev %s: %d is out of range\n",
208 return ERR_PTR(-EIO
);
211 inode
= iget_locked(sb
, ino
);
213 return ERR_PTR(-ENOMEM
);
214 if (!(inode
->i_state
& I_NEW
))
217 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
219 printk("Major problem: unable to read inode from dev %s\n",
223 /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
224 inode
->i_mode
= fs16_to_cpu(sbi
, raw_inode
->i_mode
);
225 inode
->i_uid
= (uid_t
)fs16_to_cpu(sbi
, raw_inode
->i_uid
);
226 inode
->i_gid
= (gid_t
)fs16_to_cpu(sbi
, raw_inode
->i_gid
);
227 inode
->i_nlink
= fs16_to_cpu(sbi
, raw_inode
->i_nlink
);
228 inode
->i_size
= fs32_to_cpu(sbi
, raw_inode
->i_size
);
229 inode
->i_atime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_atime
);
230 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_mtime
);
231 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sbi
, raw_inode
->i_ctime
);
232 inode
->i_ctime
.tv_nsec
= 0;
233 inode
->i_atime
.tv_nsec
= 0;
234 inode
->i_mtime
.tv_nsec
= 0;
238 for (block
= 0; block
< 10+1+1+1; block
++)
239 read3byte(sbi
, &raw_inode
->i_data
[3*block
],
240 (u8
*)&si
->i_data
[block
]);
242 si
->i_dir_start_lookup
= 0;
243 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
244 sysv_set_inode(inode
,
245 old_decode_dev(fs32_to_cpu(sbi
, si
->i_data
[0])));
247 sysv_set_inode(inode
, 0);
248 unlock_new_inode(inode
);
253 return ERR_PTR(-EIO
);
256 int sysv_write_inode(struct inode
*inode
, int wait
)
258 struct super_block
* sb
= inode
->i_sb
;
259 struct sysv_sb_info
* sbi
= SYSV_SB(sb
);
260 struct buffer_head
* bh
;
261 struct sysv_inode
* raw_inode
;
262 struct sysv_inode_info
* si
;
263 unsigned int ino
, block
;
267 if (!ino
|| ino
> sbi
->s_ninodes
) {
268 printk("Bad inode number on dev %s: %d is out of range\n",
269 inode
->i_sb
->s_id
, ino
);
272 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
274 printk("unable to read i-node block\n");
279 raw_inode
->i_mode
= cpu_to_fs16(sbi
, inode
->i_mode
);
280 raw_inode
->i_uid
= cpu_to_fs16(sbi
, fs_high2lowuid(inode
->i_uid
));
281 raw_inode
->i_gid
= cpu_to_fs16(sbi
, fs_high2lowgid(inode
->i_gid
));
282 raw_inode
->i_nlink
= cpu_to_fs16(sbi
, inode
->i_nlink
);
283 raw_inode
->i_size
= cpu_to_fs32(sbi
, inode
->i_size
);
284 raw_inode
->i_atime
= cpu_to_fs32(sbi
, inode
->i_atime
.tv_sec
);
285 raw_inode
->i_mtime
= cpu_to_fs32(sbi
, inode
->i_mtime
.tv_sec
);
286 raw_inode
->i_ctime
= cpu_to_fs32(sbi
, inode
->i_ctime
.tv_sec
);
289 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
290 si
->i_data
[0] = cpu_to_fs32(sbi
, old_encode_dev(inode
->i_rdev
));
291 for (block
= 0; block
< 10+1+1+1; block
++)
292 write3byte(sbi
, (u8
*)&si
->i_data
[block
],
293 &raw_inode
->i_data
[3*block
]);
295 mark_buffer_dirty(bh
);
297 sync_dirty_buffer(bh
);
298 if (buffer_req(bh
) && !buffer_uptodate(bh
)) {
299 printk ("IO error syncing sysv inode [%s:%08x]\n",
308 int sysv_sync_inode(struct inode
*inode
)
310 return sysv_write_inode(inode
, 1);
313 static void sysv_delete_inode(struct inode
*inode
)
315 truncate_inode_pages(&inode
->i_data
, 0);
317 sysv_truncate(inode
);
319 sysv_free_inode(inode
);
323 static struct kmem_cache
*sysv_inode_cachep
;
325 static struct inode
*sysv_alloc_inode(struct super_block
*sb
)
327 struct sysv_inode_info
*si
;
329 si
= kmem_cache_alloc(sysv_inode_cachep
, GFP_KERNEL
);
332 return &si
->vfs_inode
;
335 static void sysv_destroy_inode(struct inode
*inode
)
337 kmem_cache_free(sysv_inode_cachep
, SYSV_I(inode
));
340 static void init_once(void *p
)
342 struct sysv_inode_info
*si
= (struct sysv_inode_info
*)p
;
344 inode_init_once(&si
->vfs_inode
);
347 const struct super_operations sysv_sops
= {
348 .alloc_inode
= sysv_alloc_inode
,
349 .destroy_inode
= sysv_destroy_inode
,
350 .write_inode
= sysv_write_inode
,
351 .delete_inode
= sysv_delete_inode
,
352 .put_super
= sysv_put_super
,
353 .write_super
= sysv_write_super
,
354 .sync_fs
= sysv_sync_fs
,
355 .remount_fs
= sysv_remount
,
356 .statfs
= sysv_statfs
,
359 int __init
sysv_init_icache(void)
361 sysv_inode_cachep
= kmem_cache_create("sysv_inode_cache",
362 sizeof(struct sysv_inode_info
), 0,
363 SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
,
365 if (!sysv_inode_cachep
)
370 void sysv_destroy_icache(void)
372 kmem_cache_destroy(sysv_inode_cachep
);