This source file includes following definitions.
- msdos_format_name
- msdos_find
- msdos_lookup
- msdos_create_entry
- msdos_create
- dump_fat
- msdos_mkdir
- msdos_empty
- msdos_rmdir
- msdos_unlinkx
- msdos_unlink
- msdos_unlink_umsdos
- rename_same_dir
- rename_diff_dir
- msdos_rename
1
2
3
4
5
6
7 #include <asm/segment.h>
8
9 #include <linux/sched.h>
10 #include <linux/msdos_fs.h>
11 #include <linux/kernel.h>
12 #include <linux/errno.h>
13 #include <linux/string.h>
14 #include <linux/stat.h>
15
16
17
18 static char *reserved_names[] = {
19 "CON ","PRN ","NUL ","AUX ",
20 "LPT1 ","LPT2 ","LPT3 ","LPT4 ",
21 "COM1 ","COM2 ","COM3 ","COM4 ",
22 NULL };
23
24
25
26
27 static char bad_chars[] = "*?<>|\"";
28 static char bad_if_strict[] = "+=,; ";
29
30
31
32
33 static int msdos_format_name(char conv,const char *name,int len,char *res,
34 int dot_dirs)
35 {
36 char *walk,**reserved;
37 unsigned char c;
38 int space;
39
40 if (IS_FREE(name)) return -EINVAL;
41 if (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
42 if (!dot_dirs) return -EEXIST;
43 memset(res+1,' ',10);
44 while (len--) *res++ = '.';
45 return 0;
46 }
47 space = 1;
48 c = 0;
49 for (walk = res; len && walk-res < 8; walk++) {
50 c = *name++;
51 len--;
52 if (conv != 'r' && strchr(bad_chars,c)) return -EINVAL;
53 if (conv == 's' && strchr(bad_if_strict,c)) return -EINVAL;
54 if (c >= 'A' && c <= 'Z' && conv == 's') return -EINVAL;
55 if (c < ' ' || c == ':' || c == '\\') return -EINVAL;
56 if (c == '.') break;
57 space = c == ' ';
58 *walk = c >= 'a' && c <= 'z' ? c-32 : c;
59 }
60 if (space) return -EINVAL;
61 if (conv == 's' && len && c != '.') {
62 c = *name++;
63 len--;
64 if (c != '.') return -EINVAL;
65 }
66 while (c != '.' && len--) c = *name++;
67 if (c == '.') {
68 while (walk-res < 8) *walk++ = ' ';
69 while (len > 0 && walk-res < MSDOS_NAME) {
70 c = *name++;
71 len--;
72 if (conv != 'r' && strchr(bad_chars,c)) return -EINVAL;
73 if (conv == 's' && strchr(bad_if_strict,c))
74 return -EINVAL;
75 if (c < ' ' || c == ':' || c == '\\' || c == '.')
76 return -EINVAL;
77 if (c >= 'A' && c <= 'Z' && conv == 's') return -EINVAL;
78 space = c == ' ';
79 *walk++ = c >= 'a' && c <= 'z' ? c-32 : c;
80 }
81 if (space) return -EINVAL;
82 if (conv == 's' && len) return -EINVAL;
83 }
84 while (walk-res < MSDOS_NAME) *walk++ = ' ';
85 for (reserved = reserved_names; *reserved; reserved++)
86 if (!strncmp(res,*reserved,8)) return -EINVAL;
87 return 0;
88 }
89
90
91
92
93 static int msdos_find(struct inode *dir,const char *name,int len,
94 struct buffer_head **bh,struct msdos_dir_entry **de,int *ino)
95 {
96 char msdos_name[MSDOS_NAME];
97 int res;
98
99 if ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
100 msdos_name,1)) < 0) return res;
101 return msdos_scan(dir,msdos_name,bh,de,ino);
102 }
103
104
105 int msdos_lookup(struct inode *dir,const char *name,int len,
106 struct inode **result)
107 {
108 int ino,res;
109 struct msdos_dir_entry *de;
110 struct buffer_head *bh;
111 struct inode *next;
112
113 *result = NULL;
114 if (!dir) return -ENOENT;
115 if (!S_ISDIR(dir->i_mode)) {
116 iput(dir);
117 return -ENOENT;
118 }
119 if (len == 1 && name[0] == '.') {
120 *result = dir;
121 return 0;
122 }
123 if (len == 2 && name[0] == '.' && name[1] == '.') {
124 ino = msdos_parent_ino(dir,0);
125 iput(dir);
126 if (ino < 0) return ino;
127 if (!(*result = iget(dir->i_sb,ino))) return -EACCES;
128 return 0;
129 }
130 if ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
131 iput(dir);
132 return res;
133 }
134 if (bh) brelse(bh);
135
136 if (!(*result = iget(dir->i_sb,ino))) {
137 iput(dir);
138 return -EACCES;
139 }
140 if (MSDOS_I(*result)->i_busy) {
141 iput(*result);
142 iput(dir);
143 return -ENOENT;
144 }
145 while (MSDOS_I(*result)->i_old) {
146 next = MSDOS_I(*result)->i_old;
147 iput(*result);
148 if (!(*result = iget(next->i_sb,next->i_ino))) {
149 fs_panic(dir->i_sb,"msdos_lookup: Can't happen");
150 iput(dir);
151 return -ENOENT;
152 }
153 }
154 iput(dir);
155 return 0;
156 }
157
158
159
160
161 static int msdos_create_entry(struct inode *dir,char *name,int is_dir,
162 struct inode **result)
163 {
164 struct buffer_head *bh;
165 struct msdos_dir_entry *de;
166 int res,ino;
167
168 if ((res = msdos_scan(dir,NULL,&bh,&de,&ino)) < 0) {
169 if (res != -ENOENT) return res;
170 if (dir->i_ino == MSDOS_ROOT_INO) return -ENOSPC;
171 if ((res = msdos_add_cluster(dir)) < 0) return res;
172 if ((res = msdos_scan(dir,NULL,&bh,&de,&ino)) < 0) return res;
173 }
174
175
176
177 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
178 dir->i_dirt = 1;
179 memcpy(de->name,name,MSDOS_NAME);
180 de->attr = is_dir ? ATTR_DIR : ATTR_ARCH;
181 de->start = 0;
182 date_unix2dos(dir->i_mtime,&de->time,&de->date);
183 de->size = 0;
184 mark_buffer_dirty(bh, 1);
185 if ((*result = iget(dir->i_sb,ino)) != NULL)
186 msdos_read_inode(*result);
187 brelse(bh);
188 if (!*result) return -EIO;
189 (*result)->i_mtime = (*result)->i_atime = (*result)->i_ctime =
190 CURRENT_TIME;
191 (*result)->i_dirt = 1;
192 return 0;
193 }
194
195
196 int msdos_create(struct inode *dir,const char *name,int len,int mode,
197 struct inode **result)
198 {
199 struct buffer_head *bh;
200 struct msdos_dir_entry *de;
201 char msdos_name[MSDOS_NAME];
202 int ino,res;
203
204 if (!dir) return -ENOENT;
205 if ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
206 msdos_name,0)) < 0) {
207 iput(dir);
208 return res;
209 }
210 lock_creation();
211 if (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) {
212 unlock_creation();
213 brelse(bh);
214 iput(dir);
215 return -EEXIST;
216 }
217 res = msdos_create_entry(dir,msdos_name,S_ISDIR(mode),result);
218 unlock_creation();
219 iput(dir);
220 return res;
221 }
222
223
224 #ifdef DEBUG
225
226 static void dump_fat(struct super_block *sb,int start)
227 {
228 printk("[");
229 while (start) {
230 printk("%d ",start);
231 start = fat_access(sb,start,-1);
232 if (!start) {
233 printk("ERROR");
234 break;
235 }
236 if (start == -1) break;
237 }
238 printk("]\n");
239 }
240
241 #endif
242
243
244 int msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
245 {
246 struct buffer_head *bh;
247 struct msdos_dir_entry *de;
248 struct inode *inode,*dot;
249 char msdos_name[MSDOS_NAME];
250 int ino,res;
251
252 if ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
253 msdos_name,0)) < 0) {
254 iput(dir);
255 return res;
256 }
257 lock_creation();
258 if (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) {
259 unlock_creation();
260 brelse(bh);
261 iput(dir);
262 return -EEXIST;
263 }
264 if ((res = msdos_create_entry(dir,msdos_name,1,&inode)) < 0) {
265 unlock_creation();
266 iput(dir);
267 return res;
268 }
269 dir->i_nlink++;
270 inode->i_nlink = 2;
271 MSDOS_I(inode)->i_busy = 1;
272 if ((res = msdos_add_cluster(inode)) < 0) goto mkdir_error;
273 if ((res = msdos_create_entry(inode,MSDOS_DOT,1,&dot)) < 0)
274 goto mkdir_error;
275 dot->i_size = inode->i_size;
276 MSDOS_I(dot)->i_start = MSDOS_I(inode)->i_start;
277 dot->i_nlink = inode->i_nlink;
278 dot->i_dirt = 1;
279 iput(dot);
280 if ((res = msdos_create_entry(inode,MSDOS_DOTDOT,1,&dot)) < 0)
281 goto mkdir_error;
282 unlock_creation();
283 dot->i_size = dir->i_size;
284 MSDOS_I(dot)->i_start = MSDOS_I(dir)->i_start;
285 dot->i_nlink = dir->i_nlink;
286 dot->i_dirt = 1;
287 MSDOS_I(inode)->i_busy = 0;
288 iput(dot);
289 iput(inode);
290 iput(dir);
291 return 0;
292 mkdir_error:
293 iput(inode);
294 if (msdos_rmdir(dir,name,len) < 0)
295 fs_panic(dir->i_sb,"rmdir in mkdir failed");
296 unlock_creation();
297 return res;
298 }
299
300
301 static int msdos_empty(struct inode *dir)
302 {
303 off_t pos;
304 struct buffer_head *bh;
305 struct msdos_dir_entry *de;
306
307 if (dir->i_count > 1)
308 return -EBUSY;
309 if (MSDOS_I(dir)->i_start) {
310 pos = 0;
311 bh = NULL;
312 while (msdos_get_entry(dir,&pos,&bh,&de) > -1)
313 if (!IS_FREE(de->name) && strncmp(de->name,MSDOS_DOT,
314 MSDOS_NAME) && strncmp(de->name,MSDOS_DOTDOT,
315 MSDOS_NAME)) {
316 brelse(bh);
317 return -ENOTEMPTY;
318 }
319 if (bh)
320 brelse(bh);
321 }
322 return 0;
323 }
324
325
326 int msdos_rmdir(struct inode *dir,const char *name,int len)
327 {
328 int res,ino;
329 struct buffer_head *bh;
330 struct msdos_dir_entry *de;
331 struct inode *inode;
332
333 bh = NULL;
334 inode = NULL;
335 res = -EPERM;
336 if (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.')))
337 goto rmdir_done;
338 if ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
339 res = -ENOENT;
340 if (!(inode = iget(dir->i_sb,ino))) goto rmdir_done;
341 res = -ENOTDIR;
342 if (!S_ISDIR(inode->i_mode)) goto rmdir_done;
343 res = -EBUSY;
344 if (dir->i_dev != inode->i_dev || dir == inode) goto rmdir_done;
345 res = msdos_empty(inode);
346 if (res)
347 goto rmdir_done;
348 inode->i_nlink = 0;
349 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
350 dir->i_nlink--;
351 inode->i_dirt = dir->i_dirt = 1;
352 de->name[0] = DELETED_FLAG;
353 mark_buffer_dirty(bh, 1);
354 res = 0;
355 rmdir_done:
356 brelse(bh);
357 iput(dir);
358 iput(inode);
359 return res;
360 }
361
362
363 static int msdos_unlinkx(
364 struct inode *dir,
365 const char *name,
366 int len,
367 int nospc)
368 {
369 int res,ino;
370 struct buffer_head *bh;
371 struct msdos_dir_entry *de;
372 struct inode *inode;
373
374 bh = NULL;
375 inode = NULL;
376 if ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
377 goto unlink_done;
378 if (!(inode = iget(dir->i_sb,ino))) {
379 res = -ENOENT;
380 goto unlink_done;
381 }
382 if (!S_ISREG(inode->i_mode) && nospc){
383 res = -EPERM;
384 goto unlink_done;
385 }
386 inode->i_nlink = 0;
387 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
388 MSDOS_I(inode)->i_busy = 1;
389 inode->i_dirt = dir->i_dirt = 1;
390 de->name[0] = DELETED_FLAG;
391 mark_buffer_dirty(bh, 1);
392 unlink_done:
393 brelse(bh);
394 iput(inode);
395 iput(dir);
396 return res;
397 }
398
399 int msdos_unlink(struct inode *dir,const char *name,int len)
400 {
401 return msdos_unlinkx (dir,name,len,1);
402 }
403
404
405
406 int msdos_unlink_umsdos(struct inode *dir,const char *name,int len)
407 {
408 return msdos_unlinkx (dir,name,len,0);
409 }
410
411 static int rename_same_dir(struct inode *old_dir,char *old_name,
412 struct inode *new_dir,char *new_name,struct buffer_head *old_bh,
413 struct msdos_dir_entry *old_de,int old_ino)
414 {
415 struct buffer_head *new_bh;
416 struct msdos_dir_entry *new_de;
417 struct inode *new_inode,*old_inode;
418 int new_ino,exists,error;
419
420 if (!strncmp(old_name,new_name,MSDOS_NAME)) return 0;
421 exists = msdos_scan(new_dir,new_name,&new_bh,&new_de,&new_ino) >= 0;
422 if (*(unsigned char *) old_de->name == DELETED_FLAG) {
423 if (exists) brelse(new_bh);
424 return -ENOENT;
425 }
426 if (exists) {
427 if (!(new_inode = iget(new_dir->i_sb,new_ino))) {
428 brelse(new_bh);
429 return -EIO;
430 }
431 error = S_ISDIR(new_inode->i_mode) ? (old_de->attr & ATTR_DIR) ?
432 msdos_empty(new_inode) : -EPERM : (old_de->attr & ATTR_DIR)
433 ? -EPERM : 0;
434 if (error) {
435 iput(new_inode);
436 brelse(new_bh);
437 return error;
438 }
439 if (S_ISDIR(new_inode->i_mode)) {
440 new_dir->i_nlink--;
441 new_dir->i_dirt = 1;
442 }
443 new_inode->i_nlink = 0;
444 MSDOS_I(new_inode)->i_busy = 1;
445 new_inode->i_dirt = 1;
446 new_de->name[0] = DELETED_FLAG;
447 mark_buffer_dirty(new_bh, 1);
448 iput(new_inode);
449 brelse(new_bh);
450 }
451 memcpy(old_de->name,new_name,MSDOS_NAME);
452 mark_buffer_dirty(old_bh, 1);
453 if (MSDOS_SB(old_dir->i_sb)->conversion == 'a')
454 if ((old_inode = iget(old_dir->i_sb,old_ino)) != NULL) {
455 msdos_read_inode(old_inode);
456 iput(old_inode);
457 }
458 return 0;
459 }
460
461
462 static int rename_diff_dir(struct inode *old_dir,char *old_name,
463 struct inode *new_dir,char *new_name,struct buffer_head *old_bh,
464 struct msdos_dir_entry *old_de,int old_ino)
465 {
466 struct buffer_head *new_bh,*free_bh,*dotdot_bh;
467 struct msdos_dir_entry *new_de,*free_de,*dotdot_de;
468 struct inode *old_inode,*new_inode,*free_inode,*dotdot_inode,*walk;
469 int new_ino,free_ino,dotdot_ino;
470 int error,exists,ino;
471
472 if (old_dir->i_dev != new_dir->i_dev) return -EINVAL;
473 if (old_ino == new_dir->i_ino) return -EINVAL;
474 if (!(walk = iget(new_dir->i_sb,new_dir->i_ino))) return -EIO;
475 while (walk->i_ino != MSDOS_ROOT_INO) {
476 ino = msdos_parent_ino(walk,1);
477 iput(walk);
478 if (ino < 0) return ino;
479 if (ino == old_ino) return -EINVAL;
480 if (!(walk = iget(new_dir->i_sb,ino))) return -EIO;
481 }
482 iput(walk);
483 while ((error = msdos_scan(new_dir,NULL,&free_bh,&free_de,&free_ino)) <
484 0) {
485 if (error != -ENOENT) return error;
486 error = msdos_add_cluster(new_dir);
487 if (error) return error;
488 }
489 exists = msdos_scan(new_dir,new_name,&new_bh,&new_de,&new_ino) >= 0;
490 if (!(old_inode = iget(old_dir->i_sb,old_ino))) {
491 brelse(free_bh);
492 if (exists) brelse(new_bh);
493 return -EIO;
494 }
495 if (*(unsigned char *) old_de->name == DELETED_FLAG) {
496 iput(old_inode);
497 brelse(free_bh);
498 if (exists) brelse(new_bh);
499 return -ENOENT;
500 }
501 new_inode = NULL;
502 if (exists) {
503 if (!(new_inode = iget(new_dir->i_sb,new_ino))) {
504 iput(old_inode);
505 brelse(new_bh);
506 return -EIO;
507 }
508 error = S_ISDIR(new_inode->i_mode) ? (old_de->attr & ATTR_DIR) ?
509 msdos_empty(new_inode) : -EPERM : (old_de->attr & ATTR_DIR)
510 ? -EPERM : 0;
511 if (error) {
512 iput(new_inode);
513 iput(old_inode);
514 brelse(new_bh);
515 return error;
516 }
517 new_inode->i_nlink = 0;
518 MSDOS_I(new_inode)->i_busy = 1;
519 new_inode->i_dirt = 1;
520 new_de->name[0] = DELETED_FLAG;
521 mark_buffer_dirty(new_bh, 1);
522 }
523 memcpy(free_de,old_de,sizeof(struct msdos_dir_entry));
524 memcpy(free_de->name,new_name,MSDOS_NAME);
525 if (!(free_inode = iget(new_dir->i_sb,free_ino))) {
526 free_de->name[0] = DELETED_FLAG;
527
528 brelse(free_bh);
529 if (exists) {
530 iput(new_inode);
531 brelse(new_bh);
532 }
533 return -EIO;
534 }
535 if (exists && S_ISDIR(new_inode->i_mode)) {
536 new_dir->i_nlink--;
537 new_dir->i_dirt = 1;
538 }
539 msdos_read_inode(free_inode);
540 MSDOS_I(old_inode)->i_busy = 1;
541 cache_inval_inode(old_inode);
542 old_inode->i_dirt = 1;
543 old_de->name[0] = DELETED_FLAG;
544 mark_buffer_dirty(old_bh, 1);
545 mark_buffer_dirty(free_bh, 1);
546 if (!exists) iput(free_inode);
547 else {
548 MSDOS_I(new_inode)->i_depend = free_inode;
549 MSDOS_I(free_inode)->i_old = new_inode;
550
551 iput(new_inode);
552 brelse(new_bh);
553 }
554 if (S_ISDIR(old_inode->i_mode)) {
555 if ((error = msdos_scan(old_inode,MSDOS_DOTDOT,&dotdot_bh,
556 &dotdot_de,&dotdot_ino)) < 0) goto rename_done;
557 if (!(dotdot_inode = iget(old_inode->i_sb,dotdot_ino))) {
558 brelse(dotdot_bh);
559 error = -EIO;
560 goto rename_done;
561 }
562 dotdot_de->start = MSDOS_I(dotdot_inode)->i_start =
563 MSDOS_I(new_dir)->i_start;
564 dotdot_inode->i_dirt = 1;
565 mark_buffer_dirty(dotdot_bh, 1);
566 old_dir->i_nlink--;
567 new_dir->i_nlink++;
568
569 dotdot_inode->i_nlink = new_dir->i_nlink;
570 iput(dotdot_inode);
571 brelse(dotdot_bh);
572 }
573 error = 0;
574 rename_done:
575 brelse(free_bh);
576 iput(old_inode);
577 return error;
578 }
579
580
581 int msdos_rename(struct inode *old_dir,const char *old_name,int old_len,
582 struct inode *new_dir,const char *new_name,int new_len)
583 {
584 char old_msdos_name[MSDOS_NAME],new_msdos_name[MSDOS_NAME];
585 struct buffer_head *old_bh;
586 struct msdos_dir_entry *old_de;
587 int old_ino,error;
588
589 if ((error = msdos_format_name(MSDOS_SB(old_dir->i_sb)->name_check,
590 old_name,old_len,old_msdos_name,1)) < 0) goto rename_done;
591 if ((error = msdos_format_name(MSDOS_SB(new_dir->i_sb)->name_check,
592 new_name,new_len,new_msdos_name,0)) < 0) goto rename_done;
593 if ((error = msdos_scan(old_dir,old_msdos_name,&old_bh,&old_de,
594 &old_ino)) < 0) goto rename_done;
595 lock_creation();
596 if (old_dir == new_dir)
597 error = rename_same_dir(old_dir,old_msdos_name,new_dir,
598 new_msdos_name,old_bh,old_de,old_ino);
599 else error = rename_diff_dir(old_dir,old_msdos_name,new_dir,
600 new_msdos_name,old_bh,old_de,old_ino);
601 unlock_creation();
602 brelse(old_bh);
603 rename_done:
604 iput(old_dir);
605 iput(new_dir);
606 return error;
607 }