This source file includes following definitions.
- msdos_put_inode
- msdos_put_super
- parse_options
- msdos_read_super
- msdos_statfs
- msdos_bmap
- msdos_read_inode
- msdos_write_inode
1
2
3
4
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);
22 depend = MSDOS_I(inode)->i_depend;
23 memset(inode,0,sizeof(struct inode));
24 if (depend) {
25 if (MSDOS_I(depend)->i_old != inode) {
26 printk("Invalid link (0x%X): expected 0x%X, got "
27 "0x%X\n",(int) depend,(int) inode,(int)
28 MSDOS_I(depend)->i_old);
29 panic("That's fatal");
30 }
31 MSDOS_I(depend)->i_old = NULL;
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,
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
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;
107 printk("MSDOS bread failed\n");
108 return NULL;
109 }
110 b = (struct msdos_boot_sector *) bh->b_data;
111 s->s_blocksize = 1024;
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);
126 printk("[MS-DOS FS Rel. alpha.8, FAT %d, check=%c, conv=%c]\n",
127 MSDOS_SB(s)->fat_bits,check,conversion);
128 printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%d,ds=%d,de=%d,data=%d,se=%d,ts=%d]\n",
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;
136 printk("Unsupported FS parameters\n");
137 return NULL;
138 }
139 if (!MSDOS_CAN_BMAP(MSDOS_SB(s))) printk("No bmap support\n");
140 s->s_magic = MSDOS_SUPER_MAGIC;
141 MSDOS_SB(s)->name_check = check;
142 MSDOS_SB(s)->conversion = conversion;
143
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;
148 MSDOS_SB(s)->free_clusters = -1;
149 MSDOS_SB(s)->fat_wait = NULL;
150 MSDOS_SB(s)->fat_lock = 0;
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 {
162 int free,this;
163
164 put_fs_long(sb->s_magic,&buf->f_type);
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);
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
208
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;
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;
218 inode->i_nlink = msdos_subdirs(inode)+2;
219
220 inode->i_size = MSDOS_SB(inode->i_sb)->dir_entries*
221 sizeof(struct msdos_dir_entry);
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;
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)];
235 if ((raw_entry->attr & ATTR_DIR) && *raw_entry->name && *(unsigned char *)
236 raw_entry->name != DELETED_FLAG) {
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;
240 MSDOS_I(inode)->i_start = raw_entry->start;
241 inode->i_nlink = msdos_subdirs(inode);
242
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
249 inode->i_size = 0;
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 }
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;
265 MSDOS_I(inode)->i_start = raw_entry->start;
266 inode->i_nlink = 1;
267 inode->i_size = raw_entry->size;
268 }
269 MSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(inode->i_sb)->conversion,
270 raw_entry->ext);
271 MSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
272
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;
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 }
301 raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
302 MSDOS_I(inode)->i_attrs;
303 raw_entry->start = MSDOS_I(inode)->i_start;
304 date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
305 bh->b_dirt = 1;
306 brelse(bh);
307 }