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>
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>
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. */
35 /* An inode on disk is considered free if both i_mode == 0 and i_nlink == 0. */
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
)
41 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
43 if (sbi
->s_bh1
== sbi
->s_bh2
)
44 return &sbi
->s_sb_fic_inodes
[i
];
46 /* 512 byte Xenix FS */
47 unsigned int offset
= offsetof(struct xenix_super_block
, s_inode
[i
]);
49 return (sysv_ino_t
*)(sbi
->s_sbd1
+ offset
);
51 return (sysv_ino_t
*)(sbi
->s_sbd2
+ offset
);
56 sysv_raw_inode(struct super_block
*sb
, unsigned ino
, struct buffer_head
**bh
)
58 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
59 struct sysv_inode
*res
;
60 int block
= sbi
->s_firstinodezone
+ sbi
->s_block_base
;
62 block
+= (ino
-1) >> sbi
->s_inodes_per_block_bits
;
63 *bh
= sb_bread(sb
, block
);
66 res
= (struct sysv_inode
*)(*bh
)->b_data
;
67 return res
+ ((ino
-1) & sbi
->s_inodes_per_block_1
);
70 static int refill_free_cache(struct super_block
*sb
)
72 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
73 struct buffer_head
* bh
;
74 struct sysv_inode
* raw_inode
;
77 ino
= SYSV_ROOT_INO
+1;
78 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
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
)
87 if ((ino
++ & sbi
->s_inodes_per_block_1
) == 0) {
89 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
100 void sysv_free_inode(struct inode
* inode
)
102 struct super_block
*sb
= inode
->i_sb
;
103 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
105 struct buffer_head
* bh
;
106 struct sysv_inode
* raw_inode
;
111 if (ino
<= SYSV_ROOT_INO
|| ino
> sbi
->s_ninodes
) {
112 printk("sysv_free_inode: inode 0,1,2 or nonexistent inode\n");
115 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
117 printk("sysv_free_inode: unable to read inode block on device "
118 "%s\n", inode
->i_sb
->s_id
);
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
);
127 fs16_add(sbi
, sbi
->s_sb_total_free_inodes
, 1);
129 memset(raw_inode
, 0, sizeof(struct sysv_inode
));
130 mark_buffer_dirty(bh
);
131 mutex_unlock(&sbi
->s_lock
);
135 struct inode
* sysv_new_inode(const struct inode
* dir
, umode_t mode
)
137 struct super_block
*sb
= dir
->i_sb
;
138 struct sysv_sb_info
*sbi
= SYSV_SB(sb
);
142 struct writeback_control wbc
= {
143 .sync_mode
= WB_SYNC_NONE
146 inode
= new_inode(sb
);
148 return ERR_PTR(-ENOMEM
);
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
);
156 mutex_unlock(&sbi
->s_lock
);
157 return ERR_PTR(-ENOSPC
);
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);
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
;
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
);
174 sysv_write_inode(inode
, &wbc
); /* ensure inode not allocated again */
175 mark_inode_dirty(inode
); /* cleared by sysv_write_inode() */
177 mutex_unlock(&sbi
->s_lock
);
181 unsigned long sysv_count_free_inodes(struct super_block
* sb
)
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
;
188 mutex_lock(&sbi
->s_lock
);
190 sb_count
= fs16_to_cpu(sbi
, *sbi
->s_sb_total_free_inodes
);
195 /* this causes a lot of disk traffic ... */
197 ino
= SYSV_ROOT_INO
+1;
198 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
201 while (ino
<= sbi
->s_ninodes
) {
202 if (raw_inode
->i_mode
== 0 && raw_inode
->i_nlink
== 0)
204 if ((ino
++ & sbi
->s_inodes_per_block_1
) == 0) {
206 raw_inode
= sysv_raw_inode(sb
, ino
, &bh
);
213 if (count
!= sb_count
)
216 mutex_unlock(&sbi
->s_lock
);
220 printk("sysv_count_free_inodes: "
221 "free inode count was %d, correcting to %d\n",
223 if (!(sb
->s_flags
& MS_RDONLY
)) {
224 *sbi
->s_sb_total_free_inodes
= cpu_to_fs16(SYSV_SB(sb
), count
);
230 printk("sysv_count_free_inodes: unable to read inode table\n");
This page took 0.037504 seconds and 5 git commands to generate.