CRED: Wrap task credential accesses in the SYSV filesystem
[linux-2.6.git] / fs / sysv / ialloc.c
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 }