2 * linux/fs/sysv/ialloc.c
5 * Copyright (C) 1991, 1992 Linus Torvalds
8 * Copyright (C) 1992 Remy Card (card@masi.ibp.fr)
11 * Copyright (C) 1992 Doug Evans
14 * Copyright (C) 1993 Pascal Haible, Bruno Haible
17 * Copyright (C) 1993 Bruno Haible
19 * This file contains code for allocating/freeing inodes.
22 #include <linux/kernel.h>
24 #include <linux/sysv_fs.h>
25 #include <linux/stddef.h>
26 #include <linux/stat.h>
27 #include <linux/string.h>
28 #include <linux/locks.h>
30 /* We don't trust the value of
31 sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
32 but we nevertheless keep it up to date. */
34 /* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
36 /* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
37 static inline sysv_ino_t *
38 sv_sb_fic_inode(struct super_block * sb, unsigned int i)
40 if (sb->sv_bh1 == sb->sv_bh2)
41 return &sb->sv_sb_fic_inodes[i];
43 /* 512 byte Xenix FS */
44 unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
46 return (sysv_ino_t*)(sb->sv_sbd1 + offset);
48 return (sysv_ino_t*)(sb->sv_sbd2 + offset);
53 sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
55 struct sysv_inode *res;
56 int block = sb->sv_firstinodezone + sb->sv_block_base;
57 block += (ino-1) >> sb->sv_inodes_per_block_bits;
58 *bh = sb_bread(sb, block);
61 res = (struct sysv_inode *) (*bh)->b_data;
62 return res + ((ino-1) & sb->sv_inodes_per_block_1);
65 static int refill_free_cache(struct super_block *sb)
67 struct buffer_head * bh;
68 struct sysv_inode * raw_inode;
71 ino = SYSV_ROOT_INO+1;
72 raw_inode = sysv_raw_inode(sb, ino, &bh);
75 while (ino <= sb->sv_ninodes) {
76 if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
77 *sv_sb_fic_inode(sb,i++) = cpu_to_fs16(sb, ino);
78 if (i == sb->sv_fic_size)
81 if ((ino++ & sb->sv_inodes_per_block_1) == 0) {
83 raw_inode = sysv_raw_inode(sb, ino, &bh);
94 void sysv_free_inode(struct inode * inode)
96 struct super_block * sb;
98 struct buffer_head * bh;
99 struct sysv_inode * raw_inode;
104 if (ino <= SYSV_ROOT_INO || ino > sb->sv_ninodes) {
105 printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
108 raw_inode = sysv_raw_inode(sb, ino, &bh);
111 printk("sysv_free_inode: unable to read inode block on device "
112 "%s\n", bdevname(inode->i_dev));
116 count = fs16_to_cpu(sb, *sb->sv_sb_fic_count);
117 if (count < sb->sv_fic_size) {
118 *sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sb, ino);
119 *sb->sv_sb_fic_count = cpu_to_fs16(sb, count);
121 fs16_add(sb, sb->sv_sb_total_free_inodes, 1);
123 memset(raw_inode, 0, sizeof(struct sysv_inode));
124 mark_buffer_dirty(bh);
129 struct inode * sysv_new_inode(const struct inode * dir, mode_t mode)
131 struct inode * inode;
132 struct super_block * sb;
137 inode = new_inode(sb);
139 return ERR_PTR(-ENOMEM);
142 count = fs16_to_cpu(sb, *sb->sv_sb_fic_count);
143 if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
144 count = refill_free_cache(sb);
148 return ERR_PTR(-ENOSPC);
152 ino = *sv_sb_fic_inode(sb,--count);
153 *sb->sv_sb_fic_count = cpu_to_fs16(sb, count);
154 fs16_add(sb, sb->sv_sb_total_free_inodes, -1);
157 if (dir->i_mode & S_ISGID) {
158 inode->i_gid = dir->i_gid;
162 inode->i_gid = current->fsgid;
164 inode->i_uid = current->fsuid;
165 inode->i_ino = fs16_to_cpu(sb, ino);
166 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
167 inode->i_blocks = inode->i_blksize = 0;
168 inode->u.sysv_i.i_dir_start_lookup = 0;
169 insert_inode_hash(inode);
170 mark_inode_dirty(inode);
172 inode->i_mode = mode; /* for sysv_write_inode() */
173 sysv_write_inode(inode, 0); /* ensure inode not allocated again */
174 mark_inode_dirty(inode); /* cleared by sysv_write_inode() */
180 unsigned long sysv_count_free_inodes(struct super_block * sb)
182 struct buffer_head * bh;
183 struct sysv_inode * raw_inode;
184 int ino, count, sb_count;
188 sb_count = fs16_to_cpu(sb, *sb->sv_sb_total_free_inodes);
193 /* this causes a lot of disk traffic ... */
195 ino = SYSV_ROOT_INO+1;
196 raw_inode = sysv_raw_inode(sb, ino, &bh);
199 while (ino <= sb->sv_ninodes) {
200 if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
202 if ((ino++ & sb->sv_inodes_per_block_1) == 0) {
204 raw_inode = sysv_raw_inode(sb, ino, &bh);
211 if (count != sb_count)
218 printk("sysv_count_free_inodes: "
219 "free inode count was %d, correcting to %d\n",
221 if (!(sb->s_flags & MS_RDONLY)) {
222 *sb->sv_sb_total_free_inodes = cpu_to_fs16(sb, count);
228 printk("sysv_count_free_inodes: unable to read inode table\n");