ialloc.c 5.8 KB

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