![[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 [Linux-0.01 rebuild] / linux / fs|
Return to inode.c CVS log | Up to [Linux-0.01 rebuild] / linux / fs |
1.1 root 1: #include <string.h>
2:
3: #include <linux/sched.h>
4: #include <linux/kernel.h>
5: #include <linux/mm.h>
6: #include <asm/system.h>
7:
8: struct m_inode inode_table[NR_INODE]={{0,},};
9:
10: static void read_inode(struct m_inode * inode);
11: static void write_inode(struct m_inode * inode);
12:
13: static inline void wait_on_inode(struct m_inode * inode)
14: {
15: cli();
16: while (inode->i_lock)
17: sleep_on(&inode->i_wait);
18: sti();
19: }
20:
21: static inline void lock_inode(struct m_inode * inode)
22: {
23: cli();
24: while (inode->i_lock)
25: sleep_on(&inode->i_wait);
26: inode->i_lock=1;
27: sti();
28: }
29:
30: static inline void unlock_inode(struct m_inode * inode)
31: {
32: inode->i_lock=0;
33: wake_up(&inode->i_wait);
34: }
35:
36: void sync_inodes(void)
37: {
38: int i;
39: struct m_inode * inode;
40:
41: inode = 0+inode_table;
42: for(i=0 ; i<NR_INODE ; i++,inode++) {
43: wait_on_inode(inode);
44: if (inode->i_dirt && !inode->i_pipe)
45: write_inode(inode);
46: }
47: }
48:
49: static int _bmap(struct m_inode * inode,int block,int create)
50: {
51: struct buffer_head * bh;
52: int i;
53:
54: if (block<0)
55: panic("_bmap: block<0");
56: if (block >= 7+512+512*512)
57: panic("_bmap: block>big");
58: if (block<7) {
59: if (create && !inode->i_zone[block])
60: if (inode->i_zone[block]=new_block(inode->i_dev)) {
61: inode->i_ctime=CURRENT_TIME;
62: inode->i_dirt=1;
63: }
64: return inode->i_zone[block];
65: }
66: block -= 7;
67: if (block<512) {
68: if (create && !inode->i_zone[7])
69: if (inode->i_zone[7]=new_block(inode->i_dev)) {
70: inode->i_dirt=1;
71: inode->i_ctime=CURRENT_TIME;
72: }
73: if (!inode->i_zone[7])
74: return 0;
75: if (!(bh = bread(inode->i_dev,inode->i_zone[7])))
76: return 0;
77: i = ((unsigned short *) (bh->b_data))[block];
78: if (create && !i)
79: if (i=new_block(inode->i_dev)) {
80: ((unsigned short *) (bh->b_data))[block]=i;
81: bh->b_dirt=1;
82: }
83: brelse(bh);
84: return i;
85: }
86: block -= 512;
87: if (create && !inode->i_zone[8])
88: if (inode->i_zone[8]=new_block(inode->i_dev)) {
89: inode->i_dirt=1;
90: inode->i_ctime=CURRENT_TIME;
91: }
92: if (!inode->i_zone[8])
93: return 0;
94: if (!(bh=bread(inode->i_dev,inode->i_zone[8])))
95: return 0;
96: i = ((unsigned short *)bh->b_data)[block>>9];
97: if (create && !i)
98: if (i=new_block(inode->i_dev)) {
99: ((unsigned short *) (bh->b_data))[block>>9]=i;
100: bh->b_dirt=1;
101: }
102: brelse(bh);
103: if (!i)
104: return 0;
105: if (!(bh=bread(inode->i_dev,i)))
106: return 0;
107: i = ((unsigned short *)bh->b_data)[block&511];
108: if (create && !i)
109: if (i=new_block(inode->i_dev)) {
110: ((unsigned short *) (bh->b_data))[block&511]=i;
111: bh->b_dirt=1;
112: }
113: brelse(bh);
114: return i;
115: }
116:
117: int bmap(struct m_inode * inode,int block)
118: {
119: return _bmap(inode,block,0);
120: }
121:
122: int create_block(struct m_inode * inode, int block)
123: {
124: return _bmap(inode,block,1);
125: }
126:
127: void iput(struct m_inode * inode)
128: {
129: if (!inode)
130: return;
131: wait_on_inode(inode);
132: if (!inode->i_count)
133: panic("iput: trying to free free inode");
134: if (inode->i_pipe) {
135: wake_up(&inode->i_wait);
136: if (--inode->i_count)
137: return;
138: free_page(inode->i_size);
139: inode->i_count=0;
140: inode->i_dirt=0;
141: inode->i_pipe=0;
142: return;
143: }
144: if (!inode->i_dev || inode->i_count>1) {
145: inode->i_count--;
146: return;
147: }
148: repeat:
149: if (!inode->i_nlinks) {
150: truncate(inode);
151: free_inode(inode);
152: return;
153: }
154: if (inode->i_dirt) {
155: write_inode(inode); /* we can sleep - so do again */
156: wait_on_inode(inode);
157: goto repeat;
158: }
159: inode->i_count--;
160: return;
161: }
162:
163: static volatile int last_allocated_inode = 0;
164:
165: struct m_inode * get_empty_inode(void)
166: {
167: struct m_inode * inode;
168: int inr;
169:
170: while (1) {
171: inode = NULL;
172: inr = last_allocated_inode;
173: do {
174: if (!inode_table[inr].i_count) {
175: inode = inr + inode_table;
176: break;
177: }
178: inr++;
179: if (inr>=NR_INODE)
180: inr=0;
181: } while (inr != last_allocated_inode);
182: if (!inode) {
183: for (inr=0 ; inr<NR_INODE ; inr++)
184: printk("%04x: %6d\t",inode_table[inr].i_dev,
185: inode_table[inr].i_num);
186: panic("No free inodes in mem");
187: }
188: last_allocated_inode = inr;
189: wait_on_inode(inode);
190: while (inode->i_dirt) {
191: write_inode(inode);
192: wait_on_inode(inode);
193: }
194: if (!inode->i_count)
195: break;
196: }
197: memset(inode,0,sizeof(*inode));
198: inode->i_count = 1;
199: return inode;
200: }
201:
202: struct m_inode * get_pipe_inode(void)
203: {
204: struct m_inode * inode;
205:
206: if (!(inode = get_empty_inode()))
207: return NULL;
208: if (!(inode->i_size=get_free_page())) {
209: inode->i_count = 0;
210: return NULL;
211: }
212: inode->i_count = 2; /* sum of readers/writers */
213: PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
214: inode->i_pipe = 1;
215: return inode;
216: }
217:
218: struct m_inode * iget(int dev,int nr)
219: {
220: struct m_inode * inode, * empty;
221:
222: if (!dev)
223: panic("iget with dev==0");
224: empty = get_empty_inode();
225: inode = inode_table;
226: while (inode < NR_INODE+inode_table) {
227: if (inode->i_dev != dev || inode->i_num != nr) {
228: inode++;
229: continue;
230: }
231: wait_on_inode(inode);
232: if (inode->i_dev != dev || inode->i_num != nr) {
233: inode = inode_table;
234: continue;
235: }
236: inode->i_count++;
237: if (empty)
238: iput(empty);
239: return inode;
240: }
241: if (!empty)
242: return (NULL);
243: inode=empty;
244: inode->i_dev = dev;
245: inode->i_num = nr;
246: read_inode(inode);
247: return inode;
248: }
249:
250: static void read_inode(struct m_inode * inode)
251: {
252: struct super_block * sb;
253: struct buffer_head * bh;
254: int block;
255:
256: lock_inode(inode);
257: sb=get_super(inode->i_dev);
258: block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
259: (inode->i_num-1)/INODES_PER_BLOCK;
260: if (!(bh=bread(inode->i_dev,block)))
261: panic("unable to read i-node block");
262: *(struct d_inode *)inode =
263: ((struct d_inode *)bh->b_data)
264: [(inode->i_num-1)%INODES_PER_BLOCK];
265: brelse(bh);
266: unlock_inode(inode);
267: }
268:
269: static void write_inode(struct m_inode * inode)
270: {
271: struct super_block * sb;
272: struct buffer_head * bh;
273: int block;
274:
275: lock_inode(inode);
276: sb=get_super(inode->i_dev);
277: block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
278: (inode->i_num-1)/INODES_PER_BLOCK;
279: if (!(bh=bread(inode->i_dev,block)))
280: panic("unable to read i-node block");
281: ((struct d_inode *)bh->b_data)
282: [(inode->i_num-1)%INODES_PER_BLOCK] =
283: *(struct d_inode *)inode;
284: bh->b_dirt=1;
285: inode->i_dirt=0;
286: brelse(bh);
287: unlock_inode(inode);
288: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.