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