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