inode.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356
  1. /*
  2. * linux/fs/sysv/inode.c
  3. *
  4. * minix/inode.c
  5. * Copyright (C) 1991, 1992 Linus Torvalds
  6. *
  7. * xenix/inode.c
  8. * Copyright (C) 1992 Doug Evans
  9. *
  10. * coh/inode.c
  11. * Copyright (C) 1993 Pascal Haible, Bruno Haible
  12. *
  13. * sysv/inode.c
  14. * Copyright (C) 1993 Paul B. Monday
  15. *
  16. * sysv/inode.c
  17. * Copyright (C) 1993 Bruno Haible
  18. * Copyright (C) 1997, 1998 Krzysztof G. Baranowski
  19. *
  20. * This file contains code for allocating/freeing inodes and for read/writing
  21. * the superblock.
  22. */
  23. #include <linux/smp_lock.h>
  24. #include <linux/highuid.h>
  25. #include <linux/slab.h>
  26. #include <linux/init.h>
  27. #include <linux/buffer_head.h>
  28. #include <linux/vfs.h>
  29. #include <asm/byteorder.h>
  30. #include "sysv.h"
  31. /* This is only called on sync() and umount(), when s_dirt=1. */
  32. static void sysv_write_super(struct super_block *sb)
  33. {
  34. struct sysv_sb_info *sbi = SYSV_SB(sb);
  35. unsigned long time = get_seconds(), old_time;
  36. lock_kernel();
  37. if (sb->s_flags & MS_RDONLY)
  38. goto clean;
  39. /*
  40. * If we are going to write out the super block,
  41. * then attach current time stamp.
  42. * But if the filesystem was marked clean, keep it clean.
  43. */
  44. old_time = fs32_to_cpu(sbi, *sbi->s_sb_time);
  45. if (sbi->s_type == FSTYPE_SYSV4) {
  46. if (*sbi->s_sb_state == cpu_to_fs32(sbi, 0x7c269d38 - old_time))
  47. *sbi->s_sb_state = cpu_to_fs32(sbi, 0x7c269d38 - time);
  48. *sbi->s_sb_time = cpu_to_fs32(sbi, time);
  49. mark_buffer_dirty(sbi->s_bh2);
  50. }
  51. clean:
  52. sb->s_dirt = 0;
  53. unlock_kernel();
  54. }
  55. static int sysv_remount(struct super_block *sb, int *flags, char *data)
  56. {
  57. struct sysv_sb_info *sbi = SYSV_SB(sb);
  58. if (sbi->s_forced_ro)
  59. *flags |= MS_RDONLY;
  60. if (!(*flags & MS_RDONLY))
  61. sb->s_dirt = 1;
  62. return 0;
  63. }
  64. static void sysv_put_super(struct super_block *sb)
  65. {
  66. struct sysv_sb_info *sbi = SYSV_SB(sb);
  67. if (!(sb->s_flags & MS_RDONLY)) {
  68. /* XXX ext2 also updates the state here */
  69. mark_buffer_dirty(sbi->s_bh1);
  70. if (sbi->s_bh1 != sbi->s_bh2)
  71. mark_buffer_dirty(sbi->s_bh2);
  72. }
  73. brelse(sbi->s_bh1);
  74. if (sbi->s_bh1 != sbi->s_bh2)
  75. brelse(sbi->s_bh2);
  76. kfree(sbi);
  77. }
  78. static int sysv_statfs(struct dentry *dentry, struct kstatfs *buf)
  79. {
  80. struct super_block *sb = dentry->d_sb;
  81. struct sysv_sb_info *sbi = SYSV_SB(sb);
  82. buf->f_type = sb->s_magic;
  83. buf->f_bsize = sb->s_blocksize;
  84. buf->f_blocks = sbi->s_ndatazones;
  85. buf->f_bavail = buf->f_bfree = sysv_count_free_blocks(sb);
  86. buf->f_files = sbi->s_ninodes;
  87. buf->f_ffree = sysv_count_free_inodes(sb);
  88. buf->f_namelen = SYSV_NAMELEN;
  89. return 0;
  90. }
  91. /*
  92. * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32
  93. */
  94. static inline void read3byte(struct sysv_sb_info *sbi,
  95. unsigned char * from, unsigned char * to)
  96. {
  97. if (sbi->s_bytesex == BYTESEX_PDP) {
  98. to[0] = from[0];
  99. to[1] = 0;
  100. to[2] = from[1];
  101. to[3] = from[2];
  102. } else if (sbi->s_bytesex == BYTESEX_LE) {
  103. to[0] = from[0];
  104. to[1] = from[1];
  105. to[2] = from[2];
  106. to[3] = 0;
  107. } else {
  108. to[0] = 0;
  109. to[1] = from[0];
  110. to[2] = from[1];
  111. to[3] = from[2];
  112. }
  113. }
  114. static inline void write3byte(struct sysv_sb_info *sbi,
  115. unsigned char * from, unsigned char * to)
  116. {
  117. if (sbi->s_bytesex == BYTESEX_PDP) {
  118. to[0] = from[0];
  119. to[1] = from[2];
  120. to[2] = from[3];
  121. } else if (sbi->s_bytesex == BYTESEX_LE) {
  122. to[0] = from[0];
  123. to[1] = from[1];
  124. to[2] = from[2];
  125. } else {
  126. to[0] = from[1];
  127. to[1] = from[2];
  128. to[2] = from[3];
  129. }
  130. }
  131. static const struct inode_operations sysv_symlink_inode_operations = {
  132. .readlink = generic_readlink,
  133. .follow_link = page_follow_link_light,
  134. .put_link = page_put_link,
  135. .getattr = sysv_getattr,
  136. };
  137. void sysv_set_inode(struct inode *inode, dev_t rdev)
  138. {
  139. if (S_ISREG(inode->i_mode)) {
  140. inode->i_op = &sysv_file_inode_operations;
  141. inode->i_fop = &sysv_file_operations;
  142. inode->i_mapping->a_ops = &sysv_aops;
  143. } else if (S_ISDIR(inode->i_mode)) {
  144. inode->i_op = &sysv_dir_inode_operations;
  145. inode->i_fop = &sysv_dir_operations;
  146. inode->i_mapping->a_ops = &sysv_aops;
  147. } else if (S_ISLNK(inode->i_mode)) {
  148. if (inode->i_blocks) {
  149. inode->i_op = &sysv_symlink_inode_operations;
  150. inode->i_mapping->a_ops = &sysv_aops;
  151. } else
  152. inode->i_op = &sysv_fast_symlink_inode_operations;
  153. } else
  154. init_special_inode(inode, inode->i_mode, rdev);
  155. }
  156. static void sysv_read_inode(struct inode *inode)
  157. {
  158. struct super_block * sb = inode->i_sb;
  159. struct sysv_sb_info * sbi = SYSV_SB(sb);
  160. struct buffer_head * bh;
  161. struct sysv_inode * raw_inode;
  162. struct sysv_inode_info * si;
  163. unsigned int block, ino = inode->i_ino;
  164. if (!ino || ino > sbi->s_ninodes) {
  165. printk("Bad inode number on dev %s: %d is out of range\n",
  166. inode->i_sb->s_id, ino);
  167. goto bad_inode;
  168. }
  169. raw_inode = sysv_raw_inode(sb, ino, &bh);
  170. if (!raw_inode) {
  171. printk("Major problem: unable to read inode from dev %s\n",
  172. inode->i_sb->s_id);
  173. goto bad_inode;
  174. }
  175. /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */
  176. inode->i_mode = fs16_to_cpu(sbi, raw_inode->i_mode);
  177. inode->i_uid = (uid_t)fs16_to_cpu(sbi, raw_inode->i_uid);
  178. inode->i_gid = (gid_t)fs16_to_cpu(sbi, raw_inode->i_gid);
  179. inode->i_nlink = fs16_to_cpu(sbi, raw_inode->i_nlink);
  180. inode->i_size = fs32_to_cpu(sbi, raw_inode->i_size);
  181. inode->i_atime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_atime);
  182. inode->i_mtime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_mtime);
  183. inode->i_ctime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_ctime);
  184. inode->i_ctime.tv_nsec = 0;
  185. inode->i_atime.tv_nsec = 0;
  186. inode->i_mtime.tv_nsec = 0;
  187. inode->i_blocks = 0;
  188. si = SYSV_I(inode);
  189. for (block = 0; block < 10+1+1+1; block++)
  190. read3byte(sbi, &raw_inode->i_data[3*block],
  191. (u8 *)&si->i_data[block]);
  192. brelse(bh);
  193. si->i_dir_start_lookup = 0;
  194. if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  195. sysv_set_inode(inode,
  196. old_decode_dev(fs32_to_cpu(sbi, si->i_data[0])));
  197. else
  198. sysv_set_inode(inode, 0);
  199. return;
  200. bad_inode:
  201. make_bad_inode(inode);
  202. return;
  203. }
  204. static struct buffer_head * sysv_update_inode(struct inode * inode)
  205. {
  206. struct super_block * sb = inode->i_sb;
  207. struct sysv_sb_info * sbi = SYSV_SB(sb);
  208. struct buffer_head * bh;
  209. struct sysv_inode * raw_inode;
  210. struct sysv_inode_info * si;
  211. unsigned int ino, block;
  212. ino = inode->i_ino;
  213. if (!ino || ino > sbi->s_ninodes) {
  214. printk("Bad inode number on dev %s: %d is out of range\n",
  215. inode->i_sb->s_id, ino);
  216. return NULL;
  217. }
  218. raw_inode = sysv_raw_inode(sb, ino, &bh);
  219. if (!raw_inode) {
  220. printk("unable to read i-node block\n");
  221. return NULL;
  222. }
  223. raw_inode->i_mode = cpu_to_fs16(sbi, inode->i_mode);
  224. raw_inode->i_uid = cpu_to_fs16(sbi, fs_high2lowuid(inode->i_uid));
  225. raw_inode->i_gid = cpu_to_fs16(sbi, fs_high2lowgid(inode->i_gid));
  226. raw_inode->i_nlink = cpu_to_fs16(sbi, inode->i_nlink);
  227. raw_inode->i_size = cpu_to_fs32(sbi, inode->i_size);
  228. raw_inode->i_atime = cpu_to_fs32(sbi, inode->i_atime.tv_sec);
  229. raw_inode->i_mtime = cpu_to_fs32(sbi, inode->i_mtime.tv_sec);
  230. raw_inode->i_ctime = cpu_to_fs32(sbi, inode->i_ctime.tv_sec);
  231. si = SYSV_I(inode);
  232. if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  233. si->i_data[0] = cpu_to_fs32(sbi, old_encode_dev(inode->i_rdev));
  234. for (block = 0; block < 10+1+1+1; block++)
  235. write3byte(sbi, (u8 *)&si->i_data[block],
  236. &raw_inode->i_data[3*block]);
  237. mark_buffer_dirty(bh);
  238. return bh;
  239. }
  240. int sysv_write_inode(struct inode * inode, int wait)
  241. {
  242. struct buffer_head *bh;
  243. lock_kernel();
  244. bh = sysv_update_inode(inode);
  245. brelse(bh);
  246. unlock_kernel();
  247. return 0;
  248. }
  249. int sysv_sync_inode(struct inode * inode)
  250. {
  251. int err = 0;
  252. struct buffer_head *bh;
  253. bh = sysv_update_inode(inode);
  254. if (bh && buffer_dirty(bh)) {
  255. sync_dirty_buffer(bh);
  256. if (buffer_req(bh) && !buffer_uptodate(bh)) {
  257. printk ("IO error syncing sysv inode [%s:%08lx]\n",
  258. inode->i_sb->s_id, inode->i_ino);
  259. err = -1;
  260. }
  261. }
  262. else if (!bh)
  263. err = -1;
  264. brelse (bh);
  265. return err;
  266. }
  267. static void sysv_delete_inode(struct inode *inode)
  268. {
  269. truncate_inode_pages(&inode->i_data, 0);
  270. inode->i_size = 0;
  271. sysv_truncate(inode);
  272. lock_kernel();
  273. sysv_free_inode(inode);
  274. unlock_kernel();
  275. }
  276. static struct kmem_cache *sysv_inode_cachep;
  277. static struct inode *sysv_alloc_inode(struct super_block *sb)
  278. {
  279. struct sysv_inode_info *si;
  280. si = kmem_cache_alloc(sysv_inode_cachep, GFP_KERNEL);
  281. if (!si)
  282. return NULL;
  283. return &si->vfs_inode;
  284. }
  285. static void sysv_destroy_inode(struct inode *inode)
  286. {
  287. kmem_cache_free(sysv_inode_cachep, SYSV_I(inode));
  288. }
  289. static void init_once(void *p, struct kmem_cache *cachep, unsigned long flags)
  290. {
  291. struct sysv_inode_info *si = (struct sysv_inode_info *)p;
  292. if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
  293. SLAB_CTOR_CONSTRUCTOR)
  294. inode_init_once(&si->vfs_inode);
  295. }
  296. const struct super_operations sysv_sops = {
  297. .alloc_inode = sysv_alloc_inode,
  298. .destroy_inode = sysv_destroy_inode,
  299. .read_inode = sysv_read_inode,
  300. .write_inode = sysv_write_inode,
  301. .delete_inode = sysv_delete_inode,
  302. .put_super = sysv_put_super,
  303. .write_super = sysv_write_super,
  304. .remount_fs = sysv_remount,
  305. .statfs = sysv_statfs,
  306. };
  307. int __init sysv_init_icache(void)
  308. {
  309. sysv_inode_cachep = kmem_cache_create("sysv_inode_cache",
  310. sizeof(struct sysv_inode_info), 0,
  311. SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
  312. init_once, NULL);
  313. if (!sysv_inode_cachep)
  314. return -ENOMEM;
  315. return 0;
  316. }
  317. void sysv_destroy_icache(void)
  318. {
  319. kmem_cache_destroy(sysv_inode_cachep);
  320. }