ocfs2: fix the end cluster offset of FIEMAP
[linux-3.10.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 <linux/writeback.h>
29 #include "sysv.h"
30
31 /* We don't trust the value of
32    sb->sv_sbd2->s_tinode = *sb->sv_sb_total_free_inodes
33    but we nevertheless keep it up to date. */
34
35 /* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
36
37 /* return &sb->sv_sb_fic_inodes[i] = &sbd->s_inode[i]; */
38 static inline sysv_ino_t *
39 sv_sb_fic_inode(struct super_block * sb, unsigned int i)
40 {
41         struct sysv_sb_info *sbi = SYSV_SB(sb);
42
43         if (sbi->s_bh1 == sbi->s_bh2)
44                 return &sbi->s_sb_fic_inodes[i];
45         else {
46                 /* 512 byte Xenix FS */
47                 unsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
48                 if (offset < 512)
49                         return (sysv_ino_t*)(sbi->s_sbd1 + offset);
50                 else
51                         return (sysv_ino_t*)(sbi->s_sbd2 + offset);
52         }
53 }
54
55 struct sysv_inode *
56 sysv_raw_inode(struct super_block *sb, unsigned ino, struct buffer_head **bh)
57 {
58         struct sysv_sb_info *sbi = SYSV_SB(sb);
59         struct sysv_inode *res;
60         int block = sbi->s_firstinodezone + sbi->s_block_base;
61
62         block += (ino-1) >> sbi->s_inodes_per_block_bits;
63         *bh = sb_bread(sb, block);
64         if (!*bh)
65                 return NULL;
66         res = (struct sysv_inode *)(*bh)->b_data;
67         return res + ((ino-1) & sbi->s_inodes_per_block_1);
68 }
69
70 static int refill_free_cache(struct super_block *sb)
71 {
72         struct sysv_sb_info *sbi = SYSV_SB(sb);
73         struct buffer_head * bh;
74         struct sysv_inode * raw_inode;
75         int i = 0, ino;
76
77         ino = SYSV_ROOT_INO+1;
78         raw_inode = sysv_raw_inode(sb, ino, &bh);
79         if (!raw_inode)
80                 goto out;
81         while (ino <= sbi->s_ninodes) {
82                 if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0) {
83                         *sv_sb_fic_inode(sb,i++) = cpu_to_fs16(SYSV_SB(sb), ino);
84                         if (i == sbi->s_fic_size)
85                                 break;
86                 }
87                 if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
88                         brelse(bh);
89                         raw_inode = sysv_raw_inode(sb, ino, &bh);
90                         if (!raw_inode)
91                                 goto out;
92                 } else
93                         raw_inode++;
94         }
95         brelse(bh);
96 out:
97         return i;
98 }
99
100 void sysv_free_inode(struct inode * inode)
101 {
102         struct super_block *sb = inode->i_sb;
103         struct sysv_sb_info *sbi = SYSV_SB(sb);
104         unsigned int ino;
105         struct buffer_head * bh;
106         struct sysv_inode * raw_inode;
107         unsigned count;
108
109         sb = inode->i_sb;
110         ino = inode->i_ino;
111         if (ino <= SYSV_ROOT_INO || ino > sbi->s_ninodes) {
112                 printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
113                 return;
114         }
115         raw_inode = sysv_raw_inode(sb, ino, &bh);
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         mutex_lock(&sbi->s_lock);
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         mutex_unlock(&sbi->s_lock);
132         brelse(bh);
133 }
134
135 struct inode * sysv_new_inode(const struct inode * dir, umode_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         struct writeback_control wbc = {
143                 .sync_mode = WB_SYNC_NONE
144         };
145
146         inode = new_inode(sb);
147         if (!inode)
148                 return ERR_PTR(-ENOMEM);
149
150         mutex_lock(&sbi->s_lock);
151         count = fs16_to_cpu(sbi, *sbi->s_sb_fic_count);
152         if (count == 0 || (*sv_sb_fic_inode(sb,count-1) == 0)) {
153                 count = refill_free_cache(sb);
154                 if (count == 0) {
155                         iput(inode);
156                         mutex_unlock(&sbi->s_lock);
157                         return ERR_PTR(-ENOSPC);
158                 }
159         }
160         /* Now count > 0. */
161         ino = *sv_sb_fic_inode(sb,--count);
162         *sbi->s_sb_fic_count = cpu_to_fs16(sbi, count);
163         fs16_add(sbi, sbi->s_sb_total_free_inodes, -1);
164         dirty_sb(sb);
165         inode_init_owner(inode, dir, mode);
166         inode->i_ino = fs16_to_cpu(sbi, ino);
167         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
168         inode->i_blocks = 0;
169         memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
170         SYSV_I(inode)->i_dir_start_lookup = 0;
171         insert_inode_hash(inode);
172         mark_inode_dirty(inode);
173
174         sysv_write_inode(inode, &wbc);  /* ensure inode not allocated again */
175         mark_inode_dirty(inode);        /* cleared by sysv_write_inode() */
176         /* That's it. */
177         mutex_unlock(&sbi->s_lock);
178         return inode;
179 }
180
181 unsigned long sysv_count_free_inodes(struct super_block * sb)
182 {
183         struct sysv_sb_info *sbi = SYSV_SB(sb);
184         struct buffer_head * bh;
185         struct sysv_inode * raw_inode;
186         int ino, count, sb_count;
187
188         mutex_lock(&sbi->s_lock);
189
190         sb_count = fs16_to_cpu(sbi, *sbi->s_sb_total_free_inodes);
191
192         if (0)
193                 goto trust_sb;
194
195         /* this causes a lot of disk traffic ... */
196         count = 0;
197         ino = SYSV_ROOT_INO+1;
198         raw_inode = sysv_raw_inode(sb, ino, &bh);
199         if (!raw_inode)
200                 goto Eio;
201         while (ino <= sbi->s_ninodes) {
202                 if (raw_inode->i_mode == 0 && raw_inode->i_nlink == 0)
203                         count++;
204                 if ((ino++ & sbi->s_inodes_per_block_1) == 0) {
205                         brelse(bh);
206                         raw_inode = sysv_raw_inode(sb, ino, &bh);
207                         if (!raw_inode)
208                                 goto Eio;
209                 } else
210                         raw_inode++;
211         }
212         brelse(bh);
213         if (count != sb_count)
214                 goto Einval;
215 out:
216         mutex_unlock(&sbi->s_lock);
217         return count;
218
219 Einval:
220         printk("sysv_count_free_inodes: "
221                 "free inode count was %d, correcting to %d\n",
222                 sb_count, count);
223         if (!(sb->s_flags & MS_RDONLY)) {
224                 *sbi->s_sb_total_free_inodes = cpu_to_fs16(SYSV_SB(sb), count);
225                 dirty_sb(sb);
226         }
227         goto out;
228
229 Eio:
230         printk("sysv_count_free_inodes: unable to read inode table\n");
231 trust_sb:
232         count = sb_count;
233         goto out;
234 }