![[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 / msdos|
Return to inode.c CVS log | Up to [Early Linux] / linux / fs / msdos |
1.1 root 1: /*
2: * linux/fs/msdos/inode.c
3: *
4: * Written 1992 by Werner Almesberger
5: */
6:
7: #include <linux/msdos_fs.h>
8: #include <linux/kernel.h>
9: #include <linux/sched.h>
10: #include <linux/errno.h>
11: #include <linux/string.h>
12: #include <linux/stat.h>
13:
14: #include <asm/segment.h>
15:
16: void msdos_put_inode(struct inode *inode)
17: {
18: struct inode *depend;
19:
20: inode->i_size = 0;
21: msdos_truncate(inode);
1.1.1.2 ! root 22: depend = MSDOS_I(inode)->i_depend;
1.1 root 23: memset(inode,0,sizeof(struct inode));
24: if (depend) {
1.1.1.2 ! root 25: if (MSDOS_I(depend)->i_old != inode) {
1.1 root 26: printk("Invalid link (0x%X): expected 0x%X, got "
1.1.1.2 ! root 27: "0x%X\n",(int) depend,(int) inode,(int)
! 28: MSDOS_I(depend)->i_old);
1.1 root 29: panic("That's fatal");
30: }
1.1.1.2 ! root 31: MSDOS_I(depend)->i_old = NULL;
1.1 root 32: iput(depend);
33: }
34: }
35:
36:
37: void msdos_put_super(struct super_block *sb)
38: {
39: cache_inval_dev(sb->s_dev);
40: lock_super(sb);
41: sb->s_dev = 0;
42: free_super(sb);
43: return;
44: }
45:
46:
47: static struct super_operations msdos_sops = {
48: msdos_read_inode,
49: msdos_write_inode,
50: msdos_put_inode,
51: msdos_put_super,
52: NULL, /* added in 0.96c */
53: msdos_statfs
54: };
55:
56:
57: static int parse_options(char *options,char *check,char *conversion)
58: {
59: char *this,*value;
60:
61: *check = 'n';
62: *conversion = 'b';
63: if (!options) return 1;
64: for (this = strtok(options,","); this; this = strtok(NULL,",")) {
65: if (value = strchr(this,'=')) *value++ = 0;
66: if (!strcmp(this,"check") && value) {
67: if (value[0] && !value[1] && strchr("rns",*value))
68: *check = *value;
69: else if (!strcmp(value,"relaxed")) *check = 'r';
70: else if (!strcmp(value,"normal")) *check = 'n';
71: else if (!strcmp(value,"strict")) *check = 's';
72: else return 0;
73: }
74: else if (!strcmp(this,"conv") && value) {
75: if (value[0] && !value[1] && strchr("bta",*value))
76: *conversion = *value;
77: else if (!strcmp(value,"binary")) *conversion = 'b';
78: else if (!strcmp(value,"text")) *conversion = 't';
79: else if (!strcmp(value,"auto")) *conversion = 'a';
80: else return 0;
81: }
82: else return 0;
83: }
84: return 1;
85: }
86:
87:
88: /* Read the super block of an MS-DOS FS. */
89:
90: struct super_block *msdos_read_super(struct super_block *s,void *data)
91: {
92: struct buffer_head *bh;
93: struct msdos_boot_sector *b;
94: int data_sectors;
95: char check,conversion;
96:
97: if (!parse_options((char *) data,&check,&conversion)) {
98: s->s_dev = 0;
99: return NULL;
100: }
101: cache_init();
102: lock_super(s);
103: bh = bread(s->s_dev, 0, BLOCK_SIZE);
104: free_super(s);
105: if (bh == NULL) {
106: s->s_dev = 0;
1.1.1.2 ! root 107: printk("MSDOS bread failed\n");
1.1 root 108: return NULL;
109: }
110: b = (struct msdos_boot_sector *) bh->b_data;
111: s->s_blocksize = 1024; /* we cannot handle anything else yet */
112: MSDOS_SB(s)->cluster_size = b->cluster_size;
113: MSDOS_SB(s)->fats = b->fats;
114: MSDOS_SB(s)->fat_start = b->reserved;
115: MSDOS_SB(s)->fat_length = b->fat_length;
116: MSDOS_SB(s)->dir_start = b->reserved+b->fats*b->fat_length;
117: MSDOS_SB(s)->dir_entries = *((unsigned short *) &b->dir_entries);
118: MSDOS_SB(s)->data_start = MSDOS_SB(s)->dir_start+((MSDOS_SB(s)->
119: dir_entries << 5) >> 9);
120: data_sectors = (*((unsigned short *) &b->sectors) ? *((unsigned short *)
121: &b->sectors) : b->total_sect)-MSDOS_SB(s)->data_start;
122: MSDOS_SB(s)->clusters = b->cluster_size ? data_sectors/b->cluster_size :
123: 0;
124: MSDOS_SB(s)->fat_bits = MSDOS_SB(s)->clusters > MSDOS_FAT12 ? 16 : 12;
125: brelse(bh);
1.1.1.2 ! root 126: printk("[MS-DOS FS Rel. alpha.8, FAT %d, check=%c, conv=%c]\n",
1.1 root 127: MSDOS_SB(s)->fat_bits,check,conversion);
1.1.1.2 ! root 128: printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%d,ds=%d,de=%d,data=%d,se=%d,ts=%d]\n",
1.1 root 129: b->media,MSDOS_SB(s)->cluster_size,MSDOS_SB(s)->fats,MSDOS_SB(s)->fat_start,
130: MSDOS_SB(s)->fat_length,MSDOS_SB(s)->dir_start,MSDOS_SB(s)->dir_entries,
131: MSDOS_SB(s)->data_start,*(unsigned short *) &b->sectors,b->total_sect);
132: if (!MSDOS_SB(s)->fats || (MSDOS_SB(s)->dir_entries & (MSDOS_DPS-1))
133: || !b->cluster_size || MSDOS_SB(s)->clusters+2 > MSDOS_SB(s)->
134: fat_length*SECTOR_SIZE*8/MSDOS_SB(s)->fat_bits) {
135: s->s_dev = 0;
1.1.1.2 ! root 136: printk("Unsupported FS parameters\n");
1.1 root 137: return NULL;
138: }
1.1.1.2 ! root 139: if (!MSDOS_CAN_BMAP(MSDOS_SB(s))) printk("No bmap support\n");
1.1 root 140: s->s_magic = MSDOS_SUPER_MAGIC;
141: MSDOS_SB(s)->name_check = check;
142: MSDOS_SB(s)->conversion = conversion;
143: /* set up enough so that it can read an inode */
144: s->s_op = &msdos_sops;
145: MSDOS_SB(s)->fs_uid = current->uid;
146: MSDOS_SB(s)->fs_gid = current->gid;
147: MSDOS_SB(s)->fs_umask = current->umask;
1.1.1.2 ! root 148: MSDOS_SB(s)->free_clusters = -1; /* don't know yet */
! 149: MSDOS_SB(s)->fat_wait = NULL;
! 150: MSDOS_SB(s)->fat_lock = 0;
1.1 root 151: if (!(s->s_mounted = iget(s->s_dev,MSDOS_ROOT_INO))) {
152: s->s_dev = 0;
153: printk("get root inode failed\n");
154: return NULL;
155: }
156: return s;
157: }
158:
159:
160: void msdos_statfs(struct super_block *sb,struct statfs *buf)
161: {
1.1.1.2 ! root 162: int free,this;
1.1 root 163:
164: put_fs_long(sb->s_magic,&buf->f_type);
1.1.1.2 ! root 165: put_fs_long(MSDOS_SB(sb)->cluster_size*SECTOR_SIZE,&buf->f_bsize);
! 166: put_fs_long(MSDOS_SB(sb)->clusters,&buf->f_blocks);
! 167: lock_fat(sb);
! 168: if (MSDOS_SB(sb)->free_clusters != -1)
! 169: free = MSDOS_SB(sb)->free_clusters;
! 170: else {
! 171: free = 0;
! 172: for (this = 2; this < MSDOS_SB(sb)->clusters+2; this++)
! 173: if (!fat_access(sb,this,-1)) free++;
! 174: MSDOS_SB(sb)->free_clusters = free;
! 175: }
! 176: unlock_fat(sb);
1.1 root 177: put_fs_long(free,&buf->f_bfree);
178: put_fs_long(free,&buf->f_bavail);
179: put_fs_long(0,&buf->f_files);
180: put_fs_long(0,&buf->f_ffree);
181: }
182:
183:
184: int msdos_bmap(struct inode *inode,int block)
185: {
186: struct msdos_sb_info *sb;
187: int cluster,offset;
188:
189: sb = MSDOS_SB(inode->i_sb);
190: if ((sb->cluster_size & 1) || (sb->data_start & 1)) return 0;
191: if (inode->i_ino == MSDOS_ROOT_INO) {
192: if (sb->dir_start & 1) return 0;
193: return (sb->dir_start >> 1)+block;
194: }
195: cluster = (block*2)/sb->cluster_size;
196: offset = (block*2) % sb->cluster_size;
197: if (!(cluster = get_cluster(inode,cluster))) return 0;
198: return ((cluster-2)*sb->cluster_size+sb->data_start+offset) >> 1;
199: }
200:
201:
202: void msdos_read_inode(struct inode *inode)
203: {
204: struct buffer_head *bh;
205: struct msdos_dir_entry *raw_entry;
206: int this;
207:
1.1.1.2 ! root 208: /* printk("read inode %d\n",inode->i_ino); */
! 209: MSDOS_I(inode)->i_busy = 0;
! 210: MSDOS_I(inode)->i_depend = MSDOS_I(inode)->i_old = NULL;
! 211: MSDOS_I(inode)->i_binary = 1;
1.1 root 212: inode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
213: inode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
214: if (inode->i_ino == MSDOS_ROOT_INO) {
215: inode->i_mode = (0777 & ~MSDOS_SB(inode->i_sb)->fs_umask) |
216: S_IFDIR;
217: inode->i_op = &msdos_dir_inode_operations;
1.1.1.2 ! root 218: inode->i_nlink = msdos_subdirs(inode)+2;
! 219: /* subdirs (neither . nor ..) plus . and "self" */
1.1 root 220: inode->i_size = MSDOS_SB(inode->i_sb)->dir_entries*
221: sizeof(struct msdos_dir_entry);
1.1.1.2 ! root 222: inode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*
! 223: SECTOR_SIZE;
! 224: inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
! 225: inode->i_blksize;
! 226: MSDOS_I(inode)->i_start = 0;
! 227: MSDOS_I(inode)->i_attrs = 0;
1.1 root 228: inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
229: return;
230: }
231: if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS, BLOCK_SIZE)))
232: panic("unable to read i-node block");
233: raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
234: [inode->i_ino & (MSDOS_DPB-1)];
1.1.1.2 ! root 235: if ((raw_entry->attr & ATTR_DIR) && *raw_entry->name && *(unsigned char *)
! 236: raw_entry->name != DELETED_FLAG) {
1.1 root 237: inode->i_mode = MSDOS_MKMODE(raw_entry->attr,0777 &
238: ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFDIR;
239: inode->i_op = &msdos_dir_inode_operations;
1.1.1.2 ! root 240: MSDOS_I(inode)->i_start = raw_entry->start;
! 241: inode->i_nlink = msdos_subdirs(inode);
! 242: /* includes .., compensating for "self" */
! 243: #ifdef DEBUG
! 244: if (!inode->i_nlink) {
! 245: printk("directory %d: i_nlink == 0\n",inode->i_ino);
! 246: inode->i_nlink = 1;
! 247: }
! 248: #endif
1.1 root 249: inode->i_size = 0;
1.1.1.2 ! root 250: if (this = raw_entry->start)
! 251: while (this != -1) {
! 252: inode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
! 253: i_sb)->cluster_size;
! 254: if (!(this = fat_access(inode->i_sb,this,-1)))
! 255: printk("Directory %d: bad FAT\n",
! 256: inode->i_ino);
! 257: }
1.1 root 258: }
259: else {
260: inode->i_mode = MSDOS_MKMODE(raw_entry->attr,0666 &
261: ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFREG;
262: inode->i_op = MSDOS_CAN_BMAP(MSDOS_SB(inode->i_sb)) ?
263: &msdos_file_inode_operations :
264: &msdos_file_inode_operations_no_bmap;
1.1.1.2 ! root 265: MSDOS_I(inode)->i_start = raw_entry->start;
1.1 root 266: inode->i_nlink = 1;
267: inode->i_size = raw_entry->size;
268: }
1.1.1.2 ! root 269: MSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(inode->i_sb)->conversion,
1.1 root 270: raw_entry->ext);
1.1.1.2 ! root 271: MSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
! 272: /* this is as close to the truth as we can get ... */
! 273: inode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*SECTOR_SIZE;
! 274: inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
! 275: inode->i_blksize;
1.1 root 276: inode->i_mtime = inode->i_atime = inode->i_ctime =
277: date_dos2unix(raw_entry->time,raw_entry->date);
278: brelse(bh);
279: }
280:
281:
282: void msdos_write_inode(struct inode *inode)
283: {
284: struct buffer_head *bh;
285: struct msdos_dir_entry *raw_entry;
286:
287: inode->i_dirt = 0;
288: if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
289: if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS, BLOCK_SIZE)))
290: panic("unable to read i-node block");
291: raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
292: [inode->i_ino & (MSDOS_DPB-1)];
293: if (S_ISDIR(inode->i_mode)) {
294: raw_entry->attr = ATTR_DIR;
295: raw_entry->size = 0;
296: }
297: else {
298: raw_entry->attr = ATTR_NONE;
299: raw_entry->size = inode->i_size;
300: }
1.1.1.2 ! root 301: raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
! 302: MSDOS_I(inode)->i_attrs;
! 303: raw_entry->start = MSDOS_I(inode)->i_start;
1.1 root 304: date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
305: bh->b_dirt = 1;
306: brelse(bh);
307: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.