This source file includes following definitions.
- fat_put_inode
- fat_put_super
- parse_options
- fat_read_super
- fat_statfs
- fat_bmap
- is_exec
- fat_read_inode
- fat_write_inode
- fat_notify_change
- init_module
- cleanup_module
1
2
3
4
5
6
7
8 #define __NO_VERSION__
9 #include <linux/module.h>
10
11 #include <linux/msdos_fs.h>
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/errno.h>
15 #include <linux/string.h>
16 #include <linux/ctype.h>
17 #include <linux/major.h>
18 #include <linux/blkdev.h>
19 #include <linux/fs.h>
20 #include <linux/stat.h>
21 #include <linux/locks.h>
22
23 #include "msbuffer.h"
24 #include "tables.h"
25
26 #include <asm/segment.h>
27
28
29
30 void fat_put_inode(struct inode *inode)
31 {
32 struct inode *depend;
33 struct super_block *sb;
34
35 if (inode->i_nlink) {
36 if (MSDOS_I(inode)->i_busy) fat_cache_inval_inode(inode);
37 return;
38 }
39 inode->i_size = 0;
40 fat_truncate(inode);
41 depend = MSDOS_I(inode)->i_depend;
42 sb = inode->i_sb;
43 clear_inode(inode);
44 if (depend) {
45 if (MSDOS_I(depend)->i_old != inode) {
46 printk("Invalid link (0x%p): expected 0x%p, got 0x%p\n",
47 depend, inode, MSDOS_I(depend)->i_old);
48 fat_fs_panic(sb,"...");
49 return;
50 }
51 MSDOS_I(depend)->i_old = NULL;
52 iput(depend);
53 }
54 }
55
56
57 void fat_put_super(struct super_block *sb)
58 {
59 fat_cache_inval_dev(sb->s_dev);
60 set_blocksize (sb->s_dev,BLOCK_SIZE);
61 lock_super(sb);
62 sb->s_dev = 0;
63 unlock_super(sb);
64 MOD_DEC_USE_COUNT;
65 return;
66 }
67
68
69 static int parse_options(char *options,char *check,char *conversion,uid_t *uid,
70 gid_t *gid,int *umask,int *debug,int *fat,int *quiet,
71 int *blksize, char *dotsOK, char *sys_immutable)
72 {
73 char *this_char,*value;
74
75 *check = 'n';
76 *conversion = 'b';
77 *dotsOK = 0;
78 *uid = current->uid;
79 *gid = current->gid;
80 *umask = current->fs->umask;
81 *debug = *fat = *quiet = *sys_immutable = 0;
82 if (!options) return 1;
83 for (this_char = strtok(options,","); this_char; this_char = strtok(NULL,",")) {
84 if ((value = strchr(this_char,'=')) != NULL)
85 *value++ = 0;
86 if (!strcmp(this_char,"check") && value) {
87 if (value[0] && !value[1] && strchr("rns",*value))
88 *check = *value;
89 else if (!strcmp(value,"relaxed")) *check = 'r';
90 else if (!strcmp(value,"normal")) *check = 'n';
91 else if (!strcmp(value,"strict")) *check = 's';
92 else return 0;
93 }
94 else if (!strcmp(this_char,"conv") && value) {
95 if (value[0] && !value[1] && strchr("bta",*value))
96 *conversion = *value;
97 else if (!strcmp(value,"binary")) *conversion = 'b';
98 else if (!strcmp(value,"text")) *conversion = 't';
99 else if (!strcmp(value,"auto")) *conversion = 'a';
100 else return 0;
101 }
102 else if (!strcmp(this_char,"dots")) {
103 *dotsOK = 1;
104 }
105 else if (!strcmp(this_char,"nodots")) {
106 *dotsOK = 0;
107 }
108 else if (!strcmp(this_char,"dotsOK") && value) {
109 if (!strcmp(value,"yes")) *dotsOK = 1;
110 else if (!strcmp(value,"no")) *dotsOK = 0;
111 else return 0;
112 }
113 else if (!strcmp(this_char,"uid")) {
114 if (!value || !*value)
115 return 0;
116 *uid = simple_strtoul(value,&value,0);
117 if (*value)
118 return 0;
119 }
120 else if (!strcmp(this_char,"gid")) {
121 if (!value || !*value)
122 return 0;
123 *gid = simple_strtoul(value,&value,0);
124 if (*value)
125 return 0;
126 }
127 else if (!strcmp(this_char,"umask")) {
128 if (!value || !*value)
129 return 0;
130 *umask = simple_strtoul(value,&value,8);
131 if (*value)
132 return 0;
133 }
134 else if (!strcmp(this_char,"debug")) {
135 if (value) return 0;
136 *debug = 1;
137 }
138 else if (!strcmp(this_char,"fat")) {
139 if (!value || !*value)
140 return 0;
141 *fat = simple_strtoul(value,&value,0);
142 if (*value || (*fat != 12 && *fat != 16))
143 return 0;
144 }
145 else if (!strcmp(this_char,"quiet")) {
146 if (value) return 0;
147 *quiet = 1;
148 }
149 else if (!strcmp(this_char,"blocksize")) {
150 *blksize = simple_strtoul(value,&value,0);
151 if (*value)
152 return 0;
153 if (*blksize != 512 && *blksize != 1024){
154 printk ("MSDOS FS: Invalid blocksize (512 or 1024)\n");
155 }
156 }
157 else if (!strcmp(this_char,"sys_immutable")) {
158 if (value)
159 return 0;
160 *sys_immutable = 1;
161 }
162 else return 1;
163 }
164 return 1;
165 }
166
167
168
169
170 struct super_block *fat_read_super(struct super_block *sb,void *data, int silent)
171 {
172 struct buffer_head *bh;
173 struct msdos_boot_sector *b;
174 int data_sectors,logical_sector_size,sector_mult,fat_clusters=0;
175 int debug,error,fat,quiet;
176 char check,conversion,dotsOK,sys_immutable;
177 uid_t uid;
178 gid_t gid;
179 int umask;
180 int blksize = 512;
181
182 MOD_INC_USE_COUNT;
183 if (hardsect_size[MAJOR(sb->s_dev)] != NULL){
184 blksize = hardsect_size[MAJOR(sb->s_dev)][MINOR(sb->s_dev)];
185 if (blksize != 512){
186 printk ("MSDOS: Hardware sector size is %d\n",blksize);
187 }
188 }
189 if (!parse_options((char *) data,&check,&conversion,&uid,&gid,&umask,
190 &debug,&fat,&quiet,&blksize,&dotsOK,&sys_immutable)
191 || (blksize != 512 && blksize != 1024)) {
192 sb->s_dev = 0;
193 MOD_DEC_USE_COUNT;
194 return NULL;
195 }
196 cache_init();
197 lock_super(sb);
198
199 sb->s_blocksize = 1024;
200 set_blocksize(sb->s_dev, 1024);
201 bh = bread(sb->s_dev, 0, 1024);
202 unlock_super(sb);
203 if (bh == NULL || !fat_is_uptodate(sb,bh)) {
204 brelse (bh);
205 sb->s_dev = 0;
206 printk("FAT bread failed\n");
207 MOD_DEC_USE_COUNT;
208 return NULL;
209 }
210 b = (struct msdos_boot_sector *) bh->b_data;
211 set_blocksize(sb->s_dev, blksize);
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227 #define ROUND_TO_MULTIPLE(n,m) ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)
228
229
230 logical_sector_size = CF_LE_W(*(unsigned short *) &b->sector_size);
231 sector_mult = logical_sector_size >> SECTOR_BITS;
232 MSDOS_SB(sb)->cluster_size = b->cluster_size*sector_mult;
233 MSDOS_SB(sb)->fats = b->fats;
234 MSDOS_SB(sb)->fat_start = CF_LE_W(b->reserved)*sector_mult;
235 MSDOS_SB(sb)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
236 MSDOS_SB(sb)->dir_start = (CF_LE_W(b->reserved)+b->fats*CF_LE_W(
237 b->fat_length))*sector_mult;
238 MSDOS_SB(sb)->dir_entries = CF_LE_W(*((unsigned short *) &b->dir_entries
239 ));
240 MSDOS_SB(sb)->data_start = MSDOS_SB(sb)->dir_start+ROUND_TO_MULTIPLE((
241 MSDOS_SB(sb)->dir_entries << MSDOS_DIR_BITS) >> SECTOR_BITS,
242 sector_mult);
243 data_sectors = (CF_LE_W(*((unsigned short *) &b->sectors)) ?
244 CF_LE_W(*((unsigned short *) &b->sectors)) :
245 CF_LE_L(b->total_sect))*sector_mult-MSDOS_SB(sb)->data_start;
246 error = !b->cluster_size || !sector_mult;
247 if (!error) {
248 MSDOS_SB(sb)->clusters = b->cluster_size ? data_sectors/
249 b->cluster_size/sector_mult : 0;
250 MSDOS_SB(sb)->fat_bits = fat ? fat : MSDOS_SB(sb)->clusters >
251 MSDOS_FAT12 ? 16 : 12;
252 fat_clusters = MSDOS_SB(sb)->fat_length*SECTOR_SIZE*8/
253 MSDOS_SB(sb)->fat_bits;
254 error = !MSDOS_SB(sb)->fats || (MSDOS_SB(sb)->dir_entries &
255 (MSDOS_DPS-1)) || MSDOS_SB(sb)->clusters+2 > fat_clusters+
256 MSDOS_MAX_EXTRA || (logical_sector_size & (SECTOR_SIZE-1))
257 || !b->secs_track || !b->heads;
258 }
259 brelse(bh);
260
261
262
263
264 sb->s_blocksize = blksize;
265
266
267
268 sb->s_blocksize_bits = blksize == 512 ? 9 : 10;
269 if (error || debug) {
270
271 printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c,"
272 "uid=%d,gid=%d,umask=%03o%s]\n",MSDOS_SB(sb)->fat_bits,check,
273 conversion,uid,gid,umask,MSDOS_CAN_BMAP(MSDOS_SB(sb)) ?
274 ",bmap" : "");
275 printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%d,ds=%d,de=%d,data=%d,"
276 "se=%d,ts=%ld,ls=%d]\n",b->media,MSDOS_SB(sb)->cluster_size,
277 MSDOS_SB(sb)->fats,MSDOS_SB(sb)->fat_start,MSDOS_SB(sb)->
278 fat_length,MSDOS_SB(sb)->dir_start,MSDOS_SB(sb)->dir_entries,
279 MSDOS_SB(sb)->data_start,CF_LE_W(*(unsigned short *) &b->
280 sectors),(unsigned long)b->total_sect,logical_sector_size);
281 printk ("Transaction block size = %d\n",blksize);
282 }
283 if (MSDOS_SB(sb)->clusters+2 > fat_clusters)
284 MSDOS_SB(sb)->clusters = fat_clusters-2;
285 if (error) {
286 if (!silent)
287 printk("VFS: Can't find a valid MSDOS filesystem on dev "
288 "%s.\n", kdevname(sb->s_dev));
289 sb->s_dev = 0;
290 MOD_DEC_USE_COUNT;
291 return NULL;
292 }
293 sb->s_magic = MSDOS_SUPER_MAGIC;
294 MSDOS_SB(sb)->name_check = check;
295 MSDOS_SB(sb)->conversion = conversion;
296
297 MSDOS_SB(sb)->fs_uid = uid;
298 MSDOS_SB(sb)->fs_gid = gid;
299 MSDOS_SB(sb)->fs_umask = umask;
300 MSDOS_SB(sb)->quiet = quiet;
301 MSDOS_SB(sb)->dotsOK = dotsOK;
302 MSDOS_SB(sb)->sys_immutable = sys_immutable;
303 MSDOS_SB(sb)->vfat = 0;
304 MSDOS_SB(sb)->umsdos = 0;
305 MSDOS_SB(sb)->free_clusters = -1;
306 MSDOS_SB(sb)->fat_wait = NULL;
307 MSDOS_SB(sb)->fat_lock = 0;
308 MSDOS_SB(sb)->prev_free = 0;
309 if (!(sb->s_mounted = iget(sb,MSDOS_ROOT_INO))) {
310 sb->s_dev = 0;
311 printk("get root inode failed\n");
312 MOD_DEC_USE_COUNT;
313 return NULL;
314 }
315 return sb;
316 }
317
318
319 void fat_statfs(struct super_block *sb,struct statfs *buf, int bufsiz)
320 {
321 int free,nr;
322 struct statfs tmp;
323
324 lock_fat(sb);
325 if (MSDOS_SB(sb)->free_clusters != -1)
326 free = MSDOS_SB(sb)->free_clusters;
327 else {
328 free = 0;
329 for (nr = 2; nr < MSDOS_SB(sb)->clusters+2; nr++)
330 if (!fat_access(sb,nr,-1)) free++;
331 MSDOS_SB(sb)->free_clusters = free;
332 }
333 unlock_fat(sb);
334 tmp.f_type = sb->s_magic;
335 tmp.f_bsize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE;
336 tmp.f_blocks = MSDOS_SB(sb)->clusters;
337 tmp.f_bfree = free;
338 tmp.f_bavail = free;
339 tmp.f_files = 0;
340 tmp.f_ffree = 0;
341 tmp.f_namelen = 12;
342 memcpy_tofs(buf, &tmp, bufsiz);
343 }
344
345
346 int fat_bmap(struct inode *inode,int block)
347 {
348 struct msdos_sb_info *sb;
349 int cluster,offset;
350
351 sb = MSDOS_SB(inode->i_sb);
352 if (inode->i_ino == MSDOS_ROOT_INO) {
353 return sb->dir_start + block;
354 }
355 cluster = block/sb->cluster_size;
356 offset = block % sb->cluster_size;
357 if (!(cluster = get_cluster(inode,cluster))) return 0;
358 return (cluster-2)*sb->cluster_size+sb->data_start+offset;
359 }
360
361 static int is_exec(char *extension)
362 {
363 char *exe_extensions = "EXECOMBAT", *walk;
364
365 for (walk = exe_extensions; *walk; walk += 3)
366 if (!strncmp(extension, walk, 3))
367 return 1;
368 return 0;
369 }
370
371 void fat_read_inode(struct inode *inode, struct inode_operations *fs_dir_inode_ops)
372 {
373 struct super_block *sb = inode->i_sb;
374 struct buffer_head *bh;
375 struct msdos_dir_entry *raw_entry;
376 int nr;
377
378
379 MSDOS_I(inode)->i_busy = 0;
380 MSDOS_I(inode)->i_depend = MSDOS_I(inode)->i_old = NULL;
381 MSDOS_I(inode)->i_binary = 1;
382 inode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
383 inode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
384 if (inode->i_ino == MSDOS_ROOT_INO) {
385 inode->i_mode = (S_IRWXUGO & ~MSDOS_SB(inode->i_sb)->fs_umask) |
386 S_IFDIR;
387 inode->i_op = fs_dir_inode_ops;
388 inode->i_nlink = fat_subdirs(inode)+2;
389
390 inode->i_size = MSDOS_SB(inode->i_sb)->dir_entries*
391 sizeof(struct msdos_dir_entry);
392 inode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*
393 SECTOR_SIZE;
394 inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
395 inode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
396 MSDOS_I(inode)->i_start = 0;
397 MSDOS_I(inode)->i_attrs = 0;
398 inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
399 return;
400 }
401 if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
402 SECTOR_SIZE))) {
403 printk("dev = %s, ino = %ld\n",
404 kdevname(inode->i_dev), inode->i_ino);
405 panic("fat_read_inode: unable to read i-node block");
406 }
407 raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
408 [inode->i_ino & (MSDOS_DPB-1)];
409 if ((raw_entry->attr & ATTR_DIR) && !IS_FREE(raw_entry->name)) {
410 inode->i_mode = MSDOS_MKMODE(raw_entry->attr,S_IRWXUGO &
411 ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFDIR;
412 inode->i_op = fs_dir_inode_ops;
413
414 MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
415 inode->i_nlink = fat_subdirs(inode);
416
417 #ifdef DEBUG
418 if (!inode->i_nlink) {
419 printk("directory %d: i_nlink == 0\n",inode->i_ino);
420 inode->i_nlink = 1;
421 }
422 #endif
423 inode->i_size = 0;
424 if ((nr = CF_LE_W(raw_entry->start)) != 0)
425 while (nr != -1) {
426 inode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
427 i_sb)->cluster_size;
428 if (!(nr = fat_access(inode->i_sb,nr,-1))) {
429 printk("Directory %ld: bad FAT\n",
430 inode->i_ino);
431 break;
432 }
433 }
434 } else {
435 inode->i_mode = MSDOS_MKMODE(raw_entry->attr,
436 ((IS_NOEXEC(inode) || !is_exec(raw_entry->ext))
437 ? S_IRUGO|S_IWUGO : S_IRWXUGO)
438 & ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFREG;
439 inode->i_op = (sb->s_blocksize == 1024)
440 ? &fat_file_inode_operations_1024
441 : &fat_file_inode_operations;
442 MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
443 inode->i_nlink = 1;
444 inode->i_size = CF_LE_L(raw_entry->size);
445 }
446 if(raw_entry->attr & ATTR_SYS)
447 if (MSDOS_SB(inode->i_sb)->sys_immutable)
448 inode->i_flags |= S_IMMUTABLE;
449 MSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(inode->i_sb)->conversion,
450 raw_entry->ext);
451 MSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
452
453 inode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*SECTOR_SIZE;
454 inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
455 inode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
456 inode->i_mtime = inode->i_atime =
457 date_dos2unix(CF_LE_W(raw_entry->time),CF_LE_W(raw_entry->date));
458 inode->i_ctime =
459 MSDOS_SB(inode->i_sb)->vfat
460 ? date_dos2unix(CF_LE_W(raw_entry->ctime),CF_LE_W(raw_entry->cdate))
461 : inode->i_mtime;
462 brelse(bh);
463 }
464
465
466 void fat_write_inode(struct inode *inode)
467 {
468 struct super_block *sb = inode->i_sb;
469 struct buffer_head *bh;
470 struct msdos_dir_entry *raw_entry;
471
472 inode->i_dirt = 0;
473 if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
474 if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
475 SECTOR_SIZE))) {
476 printk("dev = %s, ino = %ld\n",
477 kdevname(inode->i_dev), inode->i_ino);
478 panic("msdos_write_inode: unable to read i-node block");
479 }
480 raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
481 [inode->i_ino & (MSDOS_DPB-1)];
482 if (S_ISDIR(inode->i_mode)) {
483 raw_entry->attr = ATTR_DIR;
484 raw_entry->size = 0;
485 }
486 else {
487 raw_entry->attr = ATTR_NONE;
488 raw_entry->size = CT_LE_L(inode->i_size);
489 }
490 raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
491 MSDOS_I(inode)->i_attrs;
492 raw_entry->start = CT_LE_L(MSDOS_I(inode)->i_start);
493 fat_date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
494 raw_entry->time = CT_LE_W(raw_entry->time);
495 raw_entry->date = CT_LE_W(raw_entry->date);
496 if (MSDOS_SB(sb)->vfat) {
497 fat_date_unix2dos(inode->i_ctime,&raw_entry->ctime,&raw_entry->cdate);
498 raw_entry->ctime = CT_LE_W(raw_entry->ctime);
499 raw_entry->cdate = CT_LE_W(raw_entry->cdate);
500 }
501 mark_buffer_dirty(bh, 1);
502 brelse(bh);
503 }
504
505
506 int fat_notify_change(struct inode * inode,struct iattr * attr)
507 {
508 int error;
509
510 error = inode_change_ok(inode, attr);
511 if (error)
512 return error;
513
514 if (((attr->ia_valid & ATTR_UID) &&
515 (attr->ia_uid != MSDOS_SB(inode->i_sb)->fs_uid)) ||
516 ((attr->ia_valid & ATTR_GID) &&
517 (attr->ia_gid != MSDOS_SB(inode->i_sb)->fs_gid)) ||
518 ((attr->ia_valid & ATTR_MODE) &&
519 (attr->ia_mode & ~MSDOS_VALID_MODE)))
520 error = -EPERM;
521
522 if (error)
523 return MSDOS_SB(inode->i_sb)->quiet ? 0 : error;
524
525 inode_setattr(inode, attr);
526
527 if (IS_NOEXEC(inode) && !S_ISDIR(inode->i_mode))
528 inode->i_mode &= S_IFMT | S_IRUGO | S_IWUGO;
529 else
530 inode->i_mode |= S_IXUGO;
531
532 inode->i_mode = ((inode->i_mode & S_IFMT) | ((((inode->i_mode & S_IRWXU
533 & ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IRUSR) >> 6)*S_IXUGO)) &
534 ~MSDOS_SB(inode->i_sb)->fs_umask;
535 return 0;
536 }
537
538
539 #ifdef MODULE
540 int init_module(void)
541 {
542 return init_fat_fs();
543 }
544
545
546 void cleanup_module(void)
547 {
548
549 return;
550 }
551 #endif
552