![[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.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.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);
103: if (inode->i_dirt && !inode->i_pipe)
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: if (--inode->i_count)
123: return;
124: free_page(inode->i_size);
125: inode->i_count=0;
126: inode->i_dirt=0;
127: inode->i_pipe=0;
128: return;
129: }
1.1.1.3 root 130: if (!inode->i_dev) {
1.1 root 131: inode->i_count--;
132: return;
133: }
1.1.1.3 root 134: repeat:
135: if (inode->i_count>1) {
136: inode->i_count--;
137: return;
138: }
1.1.1.5 root 139: if (!inode->i_nlink) {
1.1.1.8 ! root 140: if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode)
! 141: inode->i_sb->s_op->put_inode(inode);
1.1 root 142: return;
143: }
144: if (inode->i_dirt) {
145: write_inode(inode); /* we can sleep - so do again */
146: wait_on_inode(inode);
147: goto repeat;
148: }
149: inode->i_count--;
150: return;
151: }
152:
1.1.1.5 root 153: struct inode * get_empty_inode(void)
1.1 root 154: {
1.1.1.5 root 155: struct inode * inode;
156: static struct inode * last_inode = inode_table;
1.1.1.3 root 157: int i;
1.1 root 158:
1.1.1.3 root 159: do {
1.1 root 160: inode = NULL;
1.1.1.3 root 161: for (i = NR_INODE; i ; i--) {
162: if (++last_inode >= inode_table + NR_INODE)
163: last_inode = inode_table;
164: if (!last_inode->i_count) {
165: inode = last_inode;
166: if (!inode->i_dirt && !inode->i_lock)
167: break;
1.1 root 168: }
1.1.1.3 root 169: }
1.1 root 170: if (!inode) {
1.1.1.3 root 171: for (i=0 ; i<NR_INODE ; i++)
1.1.1.5 root 172: printk("(%04x: %d (%o)) ",inode_table[i].i_dev,
173: inode_table[i].i_ino,inode_table[i].i_mode);
1.1 root 174: panic("No free inodes in mem");
175: }
176: wait_on_inode(inode);
177: while (inode->i_dirt) {
178: write_inode(inode);
179: wait_on_inode(inode);
180: }
1.1.1.3 root 181: } while (inode->i_count);
1.1 root 182: memset(inode,0,sizeof(*inode));
183: inode->i_count = 1;
184: return inode;
185: }
186:
1.1.1.5 root 187: struct inode * get_pipe_inode(void)
1.1 root 188: {
1.1.1.5 root 189: struct inode * inode;
1.1 root 190:
191: if (!(inode = get_empty_inode()))
192: return NULL;
193: if (!(inode->i_size=get_free_page())) {
194: inode->i_count = 0;
195: return NULL;
196: }
197: inode->i_count = 2; /* sum of readers/writers */
198: PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
199: inode->i_pipe = 1;
200: return inode;
201: }
202:
1.1.1.5 root 203: struct inode * iget(int dev,int nr)
1.1 root 204: {
1.1.1.5 root 205: struct inode * inode, * empty;
1.1 root 206:
207: if (!dev)
208: panic("iget with dev==0");
209: empty = get_empty_inode();
210: inode = inode_table;
211: while (inode < NR_INODE+inode_table) {
1.1.1.5 root 212: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 213: inode++;
214: continue;
215: }
216: wait_on_inode(inode);
1.1.1.5 root 217: if (inode->i_dev != dev || inode->i_ino != nr) {
1.1 root 218: inode = inode_table;
219: continue;
220: }
221: inode->i_count++;
1.1.1.2 root 222: if (inode->i_mount) {
223: int i;
224:
225: for (i = 0 ; i<NR_SUPER ; i++)
1.1.1.5 root 226: if (super_block[i].s_covered==inode)
1.1.1.2 root 227: break;
228: if (i >= NR_SUPER) {
229: printk("Mounted inode hasn't got sb\n");
230: if (empty)
231: iput(empty);
232: return inode;
233: }
234: iput(inode);
1.1.1.5 root 235: if (!(inode = super_block[i].s_mounted))
236: printk("iget: mounted dev has no rootinode\n");
237: else {
238: inode->i_count++;
239: wait_on_inode(inode);
240: }
1.1.1.2 root 241: }
1.1 root 242: if (empty)
243: iput(empty);
244: return inode;
245: }
246: if (!empty)
247: return (NULL);
1.1.1.5 root 248: inode = empty;
249: if (!(inode->i_sb = get_super(dev))) {
250: printk("iget: gouldn't get super-block\n\t");
251: iput(inode);
252: return NULL;
253: }
1.1 root 254: inode->i_dev = dev;
1.1.1.5 root 255: inode->i_ino = nr;
1.1 root 256: read_inode(inode);
257: return inode;
258: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.