![[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) {
1.1.1.6 ! root 76: if (inode->i_count) {
1.1.1.3 root 77: printk("inode in use on removed disk\n\r");
1.1.1.6 ! root 78: continue;
! 79: }
1.1.1.3 root 80: inode->i_dev = inode->i_dirt = 0;
81: }
82: }
83: }
84:
1.1 root 85: void sync_inodes(void)
86: {
87: int i;
1.1.1.5 root 88: struct inode * inode;
1.1 root 89:
90: inode = 0+inode_table;
91: for(i=0 ; i<NR_INODE ; i++,inode++) {
92: wait_on_inode(inode);
93: if (inode->i_dirt && !inode->i_pipe)
94: write_inode(inode);
95: }
96: }
97:
1.1.1.5 root 98: void iput(struct inode * inode)
1.1 root 99: {
100: if (!inode)
101: return;
102: wait_on_inode(inode);
103: if (!inode->i_count)
104: panic("iput: trying to free free inode");
105: if (inode->i_pipe) {
106: wake_up(&inode->i_wait);
1.1.1.4 root 107: wake_up(&inode->i_wait2);
1.1 root 108: if (--inode->i_count)
109: return;
110: free_page(inode->i_size);
111: inode->i_count=0;
112: inode->i_dirt=0;
113: inode->i_pipe=0;
114: return;
115: }
1.1.1.3 root 116: if (!inode->i_dev) {
1.1 root 117: inode->i_count--;
118: return;
119: }
1.1.1.2 root 120: if (S_ISBLK(inode->i_mode)) {
1.1.1.5 root 121: sync_dev(inode->i_rdev);
1.1.1.2 root 122: wait_on_inode(inode);
123: }
1.1.1.3 root 124: repeat:
125: if (inode->i_count>1) {
126: inode->i_count--;
127: return;
128: }
1.1.1.5 root 129: if (!inode->i_nlink) {
130: minix_truncate(inode);
131: minix_free_inode(inode);
1.1 root 132: return;
133: }
134: if (inode->i_dirt) {
135: write_inode(inode); /* we can sleep - so do again */
136: wait_on_inode(inode);
137: goto repeat;
138: }
139: inode->i_count--;
140: return;
141: }
142:
1.1.1.5 root 143: struct inode * get_empty_inode(void)
1.1 root 144: {
1.1.1.5 root 145: struct inode * inode;
146: static struct inode * last_inode = inode_table;
1.1.1.3 root 147: int i;
1.1 root 148:
1.1.1.3 root 149: do {
1.1 root 150: inode = NULL;
1.1.1.3 root 151: for (i = NR_INODE; i ; i--) {
152: if (++last_inode >= inode_table + NR_INODE)
153: last_inode = inode_table;
154: if (!last_inode->i_count) {
155: inode = last_inode;
156: if (!inode->i_dirt && !inode->i_lock)
157: break;
1.1 root 158: }
1.1.1.3 root 159: }
1.1 root 160: if (!inode) {
1.1.1.3 root 161: for (i=0 ; i<NR_INODE ; i++)
1.1.1.5 root 162: printk("(%04x: %d (%o)) ",inode_table[i].i_dev,
163: inode_table[i].i_ino,inode_table[i].i_mode);
1.1 root 164: panic("No free inodes in mem");
165: }
166: wait_on_inode(inode);
167: while (inode->i_dirt) {
168: write_inode(inode);
169: wait_on_inode(inode);
170: }
1.1.1.3 root 171: } while (inode->i_count);
1.1 root 172: memset(inode,0,sizeof(*inode));
173: inode->i_count = 1;
174: return inode;
175: }
176:
1.1.1.5 root 177: struct inode * get_pipe_inode(void)
1.1 root 178: {
1.1.1.5 root 179: struct inode * inode;
1.1 root 180:
181: if (!(inode = get_empty_inode()))
182: return NULL;
183: if (!(inode->i_size=get_free_page())) {
184: inode->i_count = 0;
185: return NULL;
186: }
187: inode->i_count = 2; /* sum of readers/writers */
188: PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
189: inode->i_pipe = 1;
190: return inode;
191: }
192:
1.1.1.5 root 193: struct inode * iget(int dev,int nr)
1.1 root 194: {
1.1.1.5 root 195: struct inode * inode, * empty;
1.1 root 196:
197: if (!dev)
198: panic("iget with dev==0");
199: empty = get_empty_inode();
200: inode = inode_table;
201: while (inode < NR_INODE+inode_table) {
1.1.1.5 root 202: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 203: inode++;
204: continue;
205: }
206: wait_on_inode(inode);
1.1.1.5 root 207: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 208: inode = inode_table;
209: continue;
210: }
211: inode->i_count++;
1.1.1.2 root 212: if (inode->i_mount) {
213: int i;
214:
215: for (i = 0 ; i<NR_SUPER ; i++)
1.1.1.5 root 216: if (super_block[i].s_covered==inode)
1.1.1.2 root 217: break;
218: if (i >= NR_SUPER) {
219: printk("Mounted inode hasn't got sb\n");
220: if (empty)
221: iput(empty);
222: return inode;
223: }
224: iput(inode);
1.1.1.5 root 225: if (!(inode = super_block[i].s_mounted))
226: printk("iget: mounted dev has no rootinode\n");
227: else {
228: inode->i_count++;
229: wait_on_inode(inode);
230: }
1.1.1.2 root 231: }
1.1 root 232: if (empty)
233: iput(empty);
234: return inode;
235: }
236: if (!empty)
237: return (NULL);
1.1.1.5 root 238: inode = empty;
239: if (!(inode->i_sb = get_super(dev))) {
240: printk("iget: gouldn't get super-block\n\t");
241: iput(inode);
242: return NULL;
243: }
1.1 root 244: inode->i_dev = dev;
1.1.1.5 root 245: inode->i_ino = nr;
1.1 root 246: read_inode(inode);
247: return inode;
248: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.