1 /*
2 * linux/fs/sysv/ialloc.c
3 *
4 * minix/bitmap.c
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 *
7 * ext/freelists.c
8 * Copyright (C) 1992 Remy Card (card@masi.ibp.fr)
9 *
10 * xenix/alloc.c
11 * Copyright (C) 1992 Doug Evans
12 *
13 * coh/alloc.c
14 * Copyright (C) 1993 Pascal Haible, Bruno Haible
15 *
16 * sysv/ialloc.c
17 * Copyright (C) 1993 Bruno Haible
18 *
19 * This file contains code for allocating/freeing inodes.
20 */
21
22 #include <linux/kernel.h>
23 #include <linux/stddef.h>
24 #include <linux/sched.h>
25 #include <linux/stat.h>
26 #include <linux/string.h>
27 #include <linux/buffer_head.h>
28 #include "sysv.h"
29
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. */
33
34 /* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
35
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)
39 {
40 struct sysv_sb_info *sbi = SYSV_SB(sb);
41
42 if (sbi->s_bh1 == sbi->s_bh2)
43 return &sbi->s_sb_fic_inodes[i];
44 else {
45 /* 512 byte Xenix FS */
46 unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
47 if (offset < 512)
48 return (sysv_ino_t*)(sbi->s_sbd1 + offset);
49 else
50 return (sysv_ino_t*)(sbi->s_sbd2 + offset);
51 }
52 }
53
54 struct sysv_inode *
55 sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
56 {
57 struct sysv_sb_info *sbi = SYSV_SB(sb);
58 struct sysv_inode *res;
59 int block = sbi->s_firstinodezone + sbi->s_block_base;
60
61 block += (ino-1) >> sbi->s_inodes_per_block_bits;
62 *bh = sb_bread(sb, block);
63 if (!*bh)
64 return NULL;
65 res = (struct sysv_inode *)(*bh)->b_data;
66 return res + ((ino-1) & sbi->s_inodes_per_block_1);
67 }
68
69 static int refill_free_cache(struct super_block *sb)
70 {
71 struct sysv_sb_info *sbi = SYSV_SB(sb);
72 struct buffer_head * bh;
73 struct sysv_inode * raw_inode;
74 int i = 0, ino;
75
76 ino = SYSV_ROOT_INO+1;
77 raw_inode = sysv_raw_inode(sb, ino, &bh);
78 if (!raw_inode)
79 goto out;
80 while (ino <= sbi->s_ninodes) {
81 if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
82 *sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
83 if (i == sbi->s_fic_size)
84 break;
85 }
86 if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
87 brelse(bh);
88 raw_inode = sysv_raw_inode(sb, ino, &bh);
89 if (!raw_inode)
90 goto out;
91 } else
92 raw_inode++;
93 }
94 brelse(bh);
95 out:
96 return i;
97 }
98
99 void sysv_free_inode(struct inode * inode)
100 {
101 struct super_block *sb = inode->i_sb;
102 struct sysv_sb_info *sbi = SYSV_SB(sb);
103 unsigned int ino;
104 struct buffer_head * bh;
105 struct sysv_inode * raw_inode;
106 unsigned count;
107
108 sb = inode->i_sb;
109 ino = inode->i_ino;
110 if (ino <= SYSV_ROOT_INO || ino > sbi->s_ninodes) {
111 printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
112 return;
113 }
114 raw_inode = sysv_raw_inode(sb, ino, &bh);
115 clear_inode(inode);
116 if (!raw_inode) {
117 printk("sysv_free_inode: unable to read inode block on device "
118 "%s\n", inode->i_sb->s_id);
119 return;
120 }
121 lock_super(sb);
122 count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
123 if (count < sbi->s_fic_size) {
124 *sv_sb_fic_inode(sb,count++) = cpu_to_fs16(sbi, ino);
125 *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
126 }
127 fs16_add(sbi, sbi->s_sb_total_free_inodes, 1);
128 dirty_sb(sb);
129 memset(raw_inode, 0, sizeof(struct sysv_inode));
130 mark_buffer_dirty(bh);
131 unlock_super(sb);
132 brelse(bh);
133 }
134
135 struct inode * sysv_new_inode(const struct inode * dir, mode_t mode)
136 {
137 struct super_block *sb = dir->i_sb;
138 struct sysv_sb_info *sbi = SYSV_SB(sb);
139 struct inode *inode;
140 sysv_ino_t ino;
141 unsigned count;
142
143 inode = new_inode(sb);
144 if (!inode)
145 return ERR_PTR(-ENOMEM);
146
147 lock_super(sb);
148 count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
149 if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
150 count = refill_free_cache(sb);
151 if (count == 0) {
152 iput(inode);
153 unlock_super(sb);
154 return ERR_PTR(-ENOSPC);
155 }
156 }
157 /* Now count > 0. */
158 ino = *sv_sb_fic_inode(sb,--count);
159 *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
160 fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
161 dirty_sb(sb);
162
163 if (dir->i_mode & S_ISGID) {
164 inode->i_gid = dir->i_gid;
165 if (S_ISDIR(mode))
166 mode |= S_ISGID;
167 } else
168 inode->i_gid = current_fsgid();
169
170 inode->i_uid = current_fsuid();
171 inode->i_ino = fs16_to_cpu(sbi, ino);
172 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
173 inode->i_blocks = 0;
174 memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
175 SYSV_I(inode)->i_dir_start_lookup = 0;
176 insert_inode_hash(inode);
177 mark_inode_dirty(inode);
178
179 inode->i_mode = mode; /* for sysv_write_inode() */
180 sysv_write_inode(inode, 0); /* ensure inode not allocated again */
181 mark_inode_dirty(inode); /* cleared by sysv_write_inode() */
182 /* That's it. */
183 unlock_super(sb);
184 return inode;
185 }
186
187 unsigned long sysv_count_free_inodes(struct super_block * sb)
188 {
189 struct sysv_sb_info *sbi = SYSV_SB(sb);
190 struct buffer_head * bh;
191 struct sysv_inode * raw_inode;
192 int ino, count, sb_count;
193
194 lock_super(sb);
195
196 sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes);
197
198 if (0)
199 goto trust_sb;
200
201 /* this causes a lot of disk traffic ... */
202 count = 0;
203 ino = SYSV_ROOT_INO+1;
204 raw_inode = sysv_raw_inode(sb, ino, &bh);
205 if (!raw_inode)
206 goto Eio;
207 while (ino <= sbi->s_ninodes) {
208 if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
209 count++;
210 if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
211 brelse(bh);
212 raw_inode = sysv_raw_inode(sb, ino, &bh);
213 if (!raw_inode)
214 goto Eio;
215 } else
216 raw_inode++;
217 }
218 brelse(bh);
219 if (count != sb_count)
220 goto Einval;
221 out:
222 unlock_super(sb);
223 return count;
224
225 Einval:
226 printk("sysv_count_free_inodes: "
227 "free inode count was %d, correcting to %d\n",
228 sb_count, count);
229 if (!(sb->s_flags & MS_RDONLY)) {
230 *sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
231 dirty_sb(sb);
232 }
233 goto out;
234
235 Eio:
236 printk("sysv_count_free_inodes: unable to read inode table\n");
237 trust_sb:
238 count = sb_count;
239 goto out;
240 }
241
|
This page was automatically generated by the
LXR engine.
|