![[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.1.8 root 7: #include <linux/string.h>
1.1.1.9 root 8: #include <linux/stat.h>
1.1 root 9: #include <linux/sched.h>
10: #include <linux/kernel.h>
11: #include <linux/mm.h>
1.1.1.10! root 12:
1.1 root 13: #include <asm/system.h>
14:
1.1.1.5 root 15: struct inode inode_table[NR_INODE]={{0,},};
1.1.1.4 root 16:
1.1.1.5 root 17: static inline void wait_on_inode(struct inode * inode)
1.1 root 18: {
19: cli();
20: while (inode->i_lock)
21: sleep_on(&inode->i_wait);
22: sti();
23: }
24:
1.1.1.5 root 25: static inline void lock_inode(struct inode * inode)
1.1 root 26: {
27: cli();
28: while (inode->i_lock)
29: sleep_on(&inode->i_wait);
30: inode->i_lock=1;
31: sti();
32: }
33:
1.1.1.5 root 34: static inline void unlock_inode(struct inode * inode)
1.1 root 35: {
36: inode->i_lock=0;
37: wake_up(&inode->i_wait);
38: }
39:
1.1.1.5 root 40: static void write_inode(struct inode * inode)
41: {
1.1.1.8 root 42: if (!inode->i_dirt)
1.1.1.5 root 43: return;
1.1.1.8 root 44: inode->i_dirt = 0;
45: lock_inode(inode);
46: if (inode->i_dev && inode->i_sb &&
47: inode->i_sb->s_op && inode->i_sb->s_op->write_inode)
48: inode->i_sb->s_op->write_inode(inode);
1.1.1.5 root 49: unlock_inode(inode);
50: }
51:
52: static void read_inode(struct inode * inode)
53: {
54: lock_inode(inode);
1.1.1.7 root 55: if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->read_inode)
56: inode->i_sb->s_op->read_inode(inode);
1.1.1.5 root 57: unlock_inode(inode);
58: }
59:
1.1.1.7 root 60: /*
61: * bmap is needed for demand-loading and paging: if this function
62: * doesn't exist for a filesystem, then those things are impossible:
63: * executables cannot be run from the filesystem etc...
64: *
65: * This isn't as bad as it sounds: the read-routines might still work,
66: * so the filesystem would be otherwise ok (for example, you might have
67: * a DOS filesystem, which doesn't lend itself to bmap very well, but
68: * you could still transfer files to/from the filesystem)
69: */
1.1.1.5 root 70: int bmap(struct inode * inode, int block)
71: {
1.1.1.7 root 72: if (inode->i_op && inode->i_op->bmap)
73: return inode->i_op->bmap(inode,block);
74: return 0;
1.1.1.5 root 75: }
76:
1.1.1.3 root 77: void invalidate_inodes(int dev)
78: {
79: int i;
1.1.1.5 root 80: struct inode * inode;
1.1.1.3 root 81:
82: inode = 0+inode_table;
83: for(i=0 ; i<NR_INODE ; i++,inode++) {
84: wait_on_inode(inode);
85: if (inode->i_dev == dev) {
1.1.1.6 root 86: if (inode->i_count) {
1.1.1.3 root 87: printk("inode in use on removed disk\n\r");
1.1.1.6 root 88: continue;
89: }
1.1.1.3 root 90: inode->i_dev = inode->i_dirt = 0;
91: }
92: }
93: }
94:
1.1 root 95: void sync_inodes(void)
96: {
97: int i;
1.1.1.5 root 98: struct inode * inode;
1.1 root 99:
100: inode = 0+inode_table;
101: for(i=0 ; i<NR_INODE ; i++,inode++) {
102: wait_on_inode(inode);
1.1.1.10! root 103: if (inode->i_dirt)
1.1 root 104: write_inode(inode);
105: }
106: }
107:
1.1.1.5 root 108: void iput(struct inode * inode)
1.1 root 109: {
110: if (!inode)
111: return;
112: wait_on_inode(inode);
1.1.1.8 root 113: if (!inode->i_count) {
114: printk("iput: trying to free free inode\n");
115: printk("device %04x, inode %d, mode=%07o\n",inode->i_rdev,
116: inode->i_ino,inode->i_mode);
117: return;
118: }
1.1 root 119: if (inode->i_pipe) {
120: wake_up(&inode->i_wait);
1.1.1.4 root 121: wake_up(&inode->i_wait2);
1.1 root 122: }
1.1.1.10! root 123: repeat:
! 124: if (inode->i_count>1) {
1.1 root 125: inode->i_count--;
126: return;
127: }
1.1.1.10! root 128: if (inode->i_pipe) {
! 129: free_page(inode->i_size);
! 130: inode->i_size = 0;
! 131: }
! 132: if (!inode->i_dev) {
1.1.1.3 root 133: inode->i_count--;
134: return;
135: }
1.1.1.5 root 136: if (!inode->i_nlink) {
1.1.1.10! root 137: if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) {
1.1.1.8 root 138: inode->i_sb->s_op->put_inode(inode);
1.1.1.10! root 139: return;
! 140: }
1.1 root 141: }
142: if (inode->i_dirt) {
143: write_inode(inode); /* we can sleep - so do again */
144: wait_on_inode(inode);
145: goto repeat;
146: }
147: inode->i_count--;
148: return;
149: }
150:
1.1.1.5 root 151: struct inode * get_empty_inode(void)
1.1 root 152: {
1.1.1.5 root 153: struct inode * inode;
154: static struct inode * last_inode = inode_table;
1.1.1.3 root 155: int i;
1.1 root 156:
1.1.1.3 root 157: do {
1.1 root 158: inode = NULL;
1.1.1.3 root 159: for (i = NR_INODE; i ; i--) {
160: if (++last_inode >= inode_table + NR_INODE)
161: last_inode = inode_table;
162: if (!last_inode->i_count) {
163: inode = last_inode;
164: if (!inode->i_dirt && !inode->i_lock)
165: break;
1.1 root 166: }
1.1.1.3 root 167: }
1.1 root 168: if (!inode) {
1.1.1.3 root 169: for (i=0 ; i<NR_INODE ; i++)
1.1.1.5 root 170: printk("(%04x: %d (%o)) ",inode_table[i].i_dev,
171: inode_table[i].i_ino,inode_table[i].i_mode);
1.1 root 172: panic("No free inodes in mem");
173: }
174: wait_on_inode(inode);
175: while (inode->i_dirt) {
176: write_inode(inode);
177: wait_on_inode(inode);
178: }
1.1.1.3 root 179: } while (inode->i_count);
1.1 root 180: memset(inode,0,sizeof(*inode));
181: inode->i_count = 1;
182: return inode;
183: }
184:
1.1.1.5 root 185: struct inode * get_pipe_inode(void)
1.1 root 186: {
1.1.1.5 root 187: struct inode * inode;
1.1 root 188:
189: if (!(inode = get_empty_inode()))
190: return NULL;
1.1.1.10! root 191: if (!(inode->i_size = get_free_page())) {
1.1 root 192: inode->i_count = 0;
193: return NULL;
194: }
195: inode->i_count = 2; /* sum of readers/writers */
196: PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
1.1.1.10! root 197: PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
1.1 root 198: inode->i_pipe = 1;
199: return inode;
200: }
201:
1.1.1.5 root 202: struct inode * iget(int dev,int nr)
1.1 root 203: {
1.1.1.5 root 204: struct inode * inode, * empty;
1.1 root 205:
206: if (!dev)
207: panic("iget with dev==0");
208: empty = get_empty_inode();
209: inode = inode_table;
210: while (inode < NR_INODE+inode_table) {
1.1.1.5 root 211: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 212: inode++;
213: continue;
214: }
215: wait_on_inode(inode);
1.1.1.5 root 216: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 217: inode = inode_table;
218: continue;
219: }
220: inode->i_count++;
1.1.1.2 root 221: if (inode->i_mount) {
222: int i;
223:
224: for (i = 0 ; i<NR_SUPER ; i++)
1.1.1.5 root 225: if (super_block[i].s_covered==inode)
1.1.1.2 root 226: break;
227: if (i >= NR_SUPER) {
228: printk("Mounted inode hasn't got sb\n");
229: if (empty)
230: iput(empty);
231: return inode;
232: }
233: iput(inode);
1.1.1.5 root 234: if (!(inode = super_block[i].s_mounted))
235: printk("iget: mounted dev has no rootinode\n");
236: else {
237: inode->i_count++;
238: wait_on_inode(inode);
239: }
1.1.1.2 root 240: }
1.1 root 241: if (empty)
242: iput(empty);
243: return inode;
244: }
245: if (!empty)
246: return (NULL);
1.1.1.5 root 247: inode = empty;
248: if (!(inode->i_sb = get_super(dev))) {
249: printk("iget: gouldn't get super-block\n\t");
250: iput(inode);
251: return NULL;
252: }
1.1 root 253: inode->i_dev = dev;
1.1.1.5 root 254: inode->i_ino = nr;
1.1 root 255: read_inode(inode);
256: return inode;
257: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.