![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to inode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / fs|
Return to inode.c CVS log | Up to [Early Linux] / linux / fs |
1.1.1.2 root 1: /*
2: * linux/fs/inode.c
3: *
4: * (C) 1991 Linus Torvalds
5: */
6:
1.1 root 7: #include <string.h>
1.1.1.2 root 8: #include <sys/stat.h>
1.1 root 9:
10: #include <linux/sched.h>
1.1.1.5 ! root 11: #include <linux/minix_fs.h>
1.1 root 12: #include <linux/kernel.h>
13: #include <linux/mm.h>
14: #include <asm/system.h>
15:
1.1.1.5 ! root 16: struct inode inode_table[NR_INODE]={{0,},};
1.1.1.4 root 17:
1.1.1.5 ! root 18: extern void minix_read_inode(struct inode * inode);
! 19: extern void minix_write_inode(struct inode * inode);
1.1 root 20:
1.1.1.5 ! root 21: static inline void wait_on_inode(struct inode * inode)
1.1 root 22: {
23: cli();
24: while (inode->i_lock)
25: sleep_on(&inode->i_wait);
26: sti();
27: }
28:
1.1.1.5 ! root 29: static inline void lock_inode(struct inode * inode)
1.1 root 30: {
31: cli();
32: while (inode->i_lock)
33: sleep_on(&inode->i_wait);
34: inode->i_lock=1;
35: sti();
36: }
37:
1.1.1.5 ! root 38: static inline void unlock_inode(struct inode * inode)
1.1 root 39: {
40: inode->i_lock=0;
41: wake_up(&inode->i_wait);
42: }
43:
1.1.1.5 ! root 44: static void write_inode(struct inode * inode)
! 45: {
! 46: lock_inode(inode);
! 47: if (!inode->i_dirt || !inode->i_dev) {
! 48: unlock_inode(inode);
! 49: return;
! 50: }
! 51: minix_write_inode(inode);
! 52: unlock_inode(inode);
! 53: }
! 54:
! 55: static void read_inode(struct inode * inode)
! 56: {
! 57: lock_inode(inode);
! 58: minix_read_inode(inode);
! 59: unlock_inode(inode);
! 60: }
! 61:
! 62: int bmap(struct inode * inode, int block)
! 63: {
! 64: return minix_bmap(inode,block);
! 65: }
! 66:
1.1.1.3 root 67: void invalidate_inodes(int dev)
68: {
69: int i;
1.1.1.5 ! root 70: struct inode * inode;
1.1.1.3 root 71:
72: inode = 0+inode_table;
73: for(i=0 ; i<NR_INODE ; i++,inode++) {
74: wait_on_inode(inode);
75: if (inode->i_dev == dev) {
76: if (inode->i_count)
77: printk("inode in use on removed disk\n\r");
78: inode->i_dev = inode->i_dirt = 0;
79: }
80: }
81: }
82:
1.1 root 83: void sync_inodes(void)
84: {
85: int i;
1.1.1.5 ! root 86: struct inode * inode;
1.1 root 87:
88: inode = 0+inode_table;
89: for(i=0 ; i<NR_INODE ; i++,inode++) {
90: wait_on_inode(inode);
91: if (inode->i_dirt && !inode->i_pipe)
92: write_inode(inode);
93: }
94: }
95:
1.1.1.5 ! root 96: void iput(struct inode * inode)
1.1 root 97: {
98: if (!inode)
99: return;
100: wait_on_inode(inode);
101: if (!inode->i_count)
102: panic("iput: trying to free free inode");
103: if (inode->i_pipe) {
104: wake_up(&inode->i_wait);
1.1.1.4 root 105: wake_up(&inode->i_wait2);
1.1 root 106: if (--inode->i_count)
107: return;
108: free_page(inode->i_size);
109: inode->i_count=0;
110: inode->i_dirt=0;
111: inode->i_pipe=0;
112: return;
113: }
1.1.1.3 root 114: if (!inode->i_dev) {
1.1 root 115: inode->i_count--;
116: return;
117: }
1.1.1.2 root 118: if (S_ISBLK(inode->i_mode)) {
1.1.1.5 ! root 119: sync_dev(inode->i_rdev);
1.1.1.2 root 120: wait_on_inode(inode);
121: }
1.1.1.3 root 122: repeat:
123: if (inode->i_count>1) {
124: inode->i_count--;
125: return;
126: }
1.1.1.5 ! root 127: if (!inode->i_nlink) {
! 128: minix_truncate(inode);
! 129: minix_free_inode(inode);
1.1 root 130: return;
131: }
132: if (inode->i_dirt) {
133: write_inode(inode); /* we can sleep - so do again */
134: wait_on_inode(inode);
135: goto repeat;
136: }
137: inode->i_count--;
138: return;
139: }
140:
1.1.1.5 ! root 141: struct inode * get_empty_inode(void)
1.1 root 142: {
1.1.1.5 ! root 143: struct inode * inode;
! 144: static struct inode * last_inode = inode_table;
1.1.1.3 root 145: int i;
1.1 root 146:
1.1.1.3 root 147: do {
1.1 root 148: inode = NULL;
1.1.1.3 root 149: for (i = NR_INODE; i ; i--) {
150: if (++last_inode >= inode_table + NR_INODE)
151: last_inode = inode_table;
152: if (!last_inode->i_count) {
153: inode = last_inode;
154: if (!inode->i_dirt && !inode->i_lock)
155: break;
1.1 root 156: }
1.1.1.3 root 157: }
1.1 root 158: if (!inode) {
1.1.1.3 root 159: for (i=0 ; i<NR_INODE ; i++)
1.1.1.5 ! root 160: printk("(%04x: %d (%o)) ",inode_table[i].i_dev,
! 161: inode_table[i].i_ino,inode_table[i].i_mode);
1.1 root 162: panic("No free inodes in mem");
163: }
164: wait_on_inode(inode);
165: while (inode->i_dirt) {
166: write_inode(inode);
167: wait_on_inode(inode);
168: }
1.1.1.3 root 169: } while (inode->i_count);
1.1 root 170: memset(inode,0,sizeof(*inode));
171: inode->i_count = 1;
172: return inode;
173: }
174:
1.1.1.5 ! root 175: struct inode * get_pipe_inode(void)
1.1 root 176: {
1.1.1.5 ! root 177: struct inode * inode;
1.1 root 178:
179: if (!(inode = get_empty_inode()))
180: return NULL;
181: if (!(inode->i_size=get_free_page())) {
182: inode->i_count = 0;
183: return NULL;
184: }
185: inode->i_count = 2; /* sum of readers/writers */
186: PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
187: inode->i_pipe = 1;
188: return inode;
189: }
190:
1.1.1.5 ! root 191: struct inode * iget(int dev,int nr)
1.1 root 192: {
1.1.1.5 ! root 193: struct inode * inode, * empty;
1.1 root 194:
195: if (!dev)
196: panic("iget with dev==0");
197: empty = get_empty_inode();
198: inode = inode_table;
199: while (inode < NR_INODE+inode_table) {
1.1.1.5 ! root 200: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 201: inode++;
202: continue;
203: }
204: wait_on_inode(inode);
1.1.1.5 ! root 205: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 206: inode = inode_table;
207: continue;
208: }
209: inode->i_count++;
1.1.1.2 root 210: if (inode->i_mount) {
211: int i;
212:
213: for (i = 0 ; i<NR_SUPER ; i++)
1.1.1.5 ! root 214: if (super_block[i].s_covered==inode)
1.1.1.2 root 215: break;
216: if (i >= NR_SUPER) {
217: printk("Mounted inode hasn't got sb\n");
218: if (empty)
219: iput(empty);
220: return inode;
221: }
222: iput(inode);
1.1.1.5 ! root 223: if (!(inode = super_block[i].s_mounted))
! 224: printk("iget: mounted dev has no rootinode\n");
! 225: else {
! 226: inode->i_count++;
! 227: wait_on_inode(inode);
! 228: }
1.1.1.2 root 229: }
1.1 root 230: if (empty)
231: iput(empty);
232: return inode;
233: }
234: if (!empty)
235: return (NULL);
1.1.1.5 ! root 236: inode = empty;
! 237: if (!(inode->i_sb = get_super(dev))) {
! 238: printk("iget: gouldn't get super-block\n\t");
! 239: iput(inode);
! 240: return NULL;
! 241: }
1.1 root 242: inode->i_dev = dev;
1.1.1.5 ! root 243: inode->i_ino = nr;
1.1 root 244: read_inode(inode);
245: return inode;
246: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.