![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to namei.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / fs / ext|
Return to namei.c CVS log | Up to [Early Linux] / linux / fs / ext |
1.1 root 1: /*
2: * linux/fs/ext/namei.c
3: *
4: * (C) 1992 Remy Card ([email protected])
5: *
6: * from
7: *
8: * linux/fs/minix/namei.c
9: *
10: * (C) 1991 Linus Torvalds
11: */
12:
13: #include <linux/sched.h>
14: #include <linux/ext_fs.h>
15: #include <linux/kernel.h>
16: #include <linux/string.h>
17: #include <linux/stat.h>
18: #include <linux/fcntl.h>
19: #include <asm/segment.h>
20:
21: #include <errno.h>
22: #include <const.h>
23:
24: /*
25: * comment out this line if you want names > EXT_NAME_LEN chars to be
26: * truncated. Else they will be disallowed.
27: */
28: /* #define NO_TRUNCATE */
29:
30: /*
31: * EXT_DIR_PAD defines the directory entries boundaries
32: *
33: * NOTE: It must be a power of 2 and must be greater or equal than 8
34: * because a directory entry needs 8 bytes for its fixed part
35: * (4 bytes for the inode, 2 bytes for the entry length and 2 bytes
36: * for the name length)
37: */
38: #define EXT_DIR_PAD 8
39:
40: /*
41: *
42: * EXT_DIR_MIN_SIZE is the minimal size of a directory entry
43: *
44: * During allocations, a directory entry is split into 2 ones
45: * *ONLY* if the size of the unused part is greater than or
46: * equal to EXT_DIR_MIN_SIZE
47: */
48: #define EXT_DIR_MIN_SIZE 12
49:
50: /*
51: * ok, we cannot use strncmp, as the name is not in our data space.
52: * Thus we'll have to use ext_match. No big problem. Match also makes
53: * some sanity tests.
54: *
55: * NOTE! unlike strncmp, ext_match returns 1 for success, 0 for failure.
56: */
57: static int ext_match(int len,const char * name,struct ext_dir_entry * de)
58: {
59: register int same __asm__("ax");
60:
61: if (!de || !de->inode || len > EXT_NAME_LEN)
62: return 0;
63: /* "" means "." ---> so paths like "/usr/lib//libc.a" work */
64: if (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
65: return 1;
66: /* if (len < EXT_NAME_LEN && de->name[len])
67: return 0; */
68: if (len < EXT_NAME_LEN && len != de->name_len)
69: return 0;
70: __asm__("cld\n\t"
71: "fs ; repe ; cmpsb\n\t"
72: "setz %%al"
73: :"=a" (same)
74: :"0" (0),"S" ((long) name),"D" ((long) de->name),"c" (len)
75: :"cx","di","si");
76: return same;
77: }
78:
79: /*
80: * ext_find_entry()
81: *
82: * finds an entry in the specified directory with the wanted name. It
83: * returns the cache buffer in which the entry was found, and the entry
84: * itself (as a parameter - res_dir). It does NOT read the inode of the
85: * entry - you'll have to do that yourself if you want to.
86: *
87: * addition for the ext file system : this function returns the previous
88: * and next directory entries in the parameters prev_dir and next_dir
89: */
90: static struct buffer_head * ext_find_entry(struct inode * dir,
91: const char * name, int namelen, struct ext_dir_entry ** res_dir,
92: struct ext_dir_entry ** prev_dir, struct ext_dir_entry ** next_dir)
93: {
94: /* int entries; */
95: int block /* ,i */;
96: long offset;
97: struct buffer_head * bh;
98: struct ext_dir_entry * de;
99:
100: *res_dir = NULL;
101: if (!dir)
102: return NULL;
103: #ifdef NO_TRUNCATE
104: if (namelen > EXT_NAME_LEN)
105: return NULL;
106: #else
107: if (namelen > EXT_NAME_LEN)
108: namelen = EXT_NAME_LEN;
109: #endif
110: /* entries = dir->i_size / (sizeof (struct ext_dir_entry)); */
111: if (!(block = dir->i_data[0]))
112: return NULL;
113: if (!(bh = bread(dir->i_dev,block)))
114: return NULL;
115: if (prev_dir)
116: *prev_dir = NULL;
117: if (next_dir)
118: *next_dir = NULL;
119: /* i = 0; */
120: offset = 0;
121: de = (struct ext_dir_entry *) bh->b_data;
122: while (offset < dir->i_size) {
123: if ((char *)de >= BLOCK_SIZE+bh->b_data) {
124: brelse(bh);
125: bh = NULL;
126: if (!(block = ext_bmap(dir,offset>>BLOCK_SIZE_BITS)) ||
127: !(bh = bread(dir->i_dev,block))) {
128: /* i += EXT_DIR_ENTRIES_PER_BLOCK; */
129: /* offset += BLOCK_SIZE; */
130: continue;
131: }
132: de = (struct ext_dir_entry *) bh->b_data;
133: if (prev_dir)
134: *prev_dir = NULL;
135: }
136: if (ext_match(namelen,name,de)) {
137: *res_dir = de;
138: if (next_dir)
139: if (offset + de->rec_len < dir->i_size)
140: *next_dir = (struct ext_dir_entry *)
141: ((char *) de + de->rec_len);
142: else
143: *next_dir = NULL;
144: return bh;
145: }
146: offset += de->rec_len;
147: if (prev_dir)
148: *prev_dir = de;
149: de = (struct ext_dir_entry *) ((char *) de + de->rec_len);
150: /* i++; */
151: }
152: brelse(bh);
153: return NULL;
154: }
155:
156: int ext_lookup(struct inode * dir,const char * name, int len,
157: struct inode ** result)
158: {
159: int ino;
160: struct ext_dir_entry * de;
161: struct buffer_head * bh;
162:
163: *result = NULL;
164: if (!dir)
165: return -ENOENT;
166: if (!S_ISDIR(dir->i_mode)) {
167: iput(dir);
168: return -ENOENT;
169: }
170: if (!(bh = ext_find_entry(dir,name,len,&de,NULL,NULL))) {
171: iput(dir);
172: return -ENOENT;
173: }
174: ino = de->inode;
175: brelse(bh);
176: if (!(*result = iget(dir->i_dev,ino))) {
177: iput(dir);
178: return -EACCES;
179: }
180: iput(dir);
181: return 0;
182: }
183:
184: /*
185: * ext_add_entry()
186: *
187: * adds a file entry to the specified directory, using the same
188: * semantics as ext_find_entry(). It returns NULL if it failed.
189: *
190: * NOTE!! The inode part of 'de' is left at 0 - which means you
191: * may not sleep between calling this and putting something into
192: * the entry, as someone else might have used it while you slept.
193: */
194: static struct buffer_head * ext_add_entry(struct inode * dir,
195: const char * name, int namelen, struct ext_dir_entry ** res_dir)
196: {
197: int block,i;
198: long offset;
199: unsigned short rec_len;
200: struct buffer_head * bh;
201: struct ext_dir_entry * de, * de1;
202:
203: *res_dir = NULL;
204: if (!dir)
205: return NULL;
206: #ifdef NO_TRUNCATE
207: if (namelen > EXT_NAME_LEN)
208: return NULL;
209: #else
210: if (namelen > EXT_NAME_LEN)
211: namelen = EXT_NAME_LEN;
212: #endif
213: if (!namelen)
214: return NULL;
215: if (!(block = dir->i_data[0]))
216: return NULL;
217: if (!(bh = bread(dir->i_dev,block)))
218: return NULL;
219: rec_len = ((8 + namelen + EXT_DIR_PAD - 1) / EXT_DIR_PAD) * EXT_DIR_PAD;
220: /* i = 0; */
221: offset = 0;
222: de = (struct ext_dir_entry *) bh->b_data;
223: while (1) {
224: if ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) {
225: #ifdef EXTFS_DEBUG
226: printk ("ext_add_entry: skipping to next block\n");
227: #endif
228: brelse(bh);
229: bh = NULL;
230: block = ext_create_block(dir,offset>>BLOCK_SIZE_BITS);
231: if (!block)
232: return NULL;
233: if (!(bh = bread(dir->i_dev,block))) {
234: /* i += EXT_DIR_ENTRIES_PER_BLOCK; */
235: offset += BLOCK_SIZE;
236: continue;
237: }
238: de = (struct ext_dir_entry *) bh->b_data;
239: }
240: if (offset >= dir->i_size) {
241: /* Check that the directory entry fits in the block */
242: if (offset % BLOCK_SIZE == 0
243: || (BLOCK_SIZE - (offset % BLOCK_SIZE)) < rec_len) {
244: if ((offset % BLOCK_SIZE) != 0) {
245: /* If the entry does not fit in the
246: block, the remainder of the block
247: becomes an unused entry */
248: de->inode = 0;
249: de->rec_len = BLOCK_SIZE
250: - (offset & (BLOCK_SIZE - 1));
251: de->name_len = 0;
252: offset += de->rec_len;
253: dir->i_size += de->rec_len;
254: dir->i_dirt = 1;
255: dir->i_ctime = CURRENT_TIME;
256: bh->b_dirt = 1;
257: }
258: brelse (bh);
259: bh = NULL;
260: block = ext_create_block (dir,offset>>BLOCK_SIZE_BITS);
261: #ifdef EXTFS_DEBUG
262: printk ("ext_add_entry : creating next block\n");
263: #endif
264: if (!block)
265: return NULL;
266: if (!(bh = bread(dir->i_dev,block)))
267: return NULL; /* Other thing to do ??? */
268: de = (struct ext_dir_entry *) bh->b_data;
269: }
270: /* Allocate the entry */
271: de->inode=0;
272: de->rec_len = rec_len;
273: /* dir->i_size = (i+1)*sizeof(struct ext_dir_entry); */
274: dir->i_size += de->rec_len;
275: dir->i_dirt = 1;
276: dir->i_ctime = CURRENT_TIME;
277: }
278: if (!de->inode && de->rec_len >= rec_len) {
279: if (de->rec_len > rec_len
280: && de->rec_len - rec_len >= EXT_DIR_MIN_SIZE) {
281: /* The found entry is too big : it is split
282: into 2 ones :
283: - the 1st one will be used to hold the name,
284: - the 2nd one is unused */
285: de1 = (struct ext_dir_entry *) ((char *) de + rec_len);
286: de1->inode = 0;
287: de1->rec_len = de->rec_len - rec_len;
288: de1->name_len = 0;
289: de->rec_len = rec_len;
290: }
291: dir->i_mtime = CURRENT_TIME;
292: de->name_len = namelen;
293: for (i=0; i < namelen ; i++)
294: de->name[i]=/*(i<namelen)?*/get_fs_byte(name+i)/*:0*/;
295: bh->b_dirt = 1;
296: *res_dir = de;
297: return bh;
298: }
299: offset += de->rec_len;
300: de = (struct ext_dir_entry *) ((char *) de + de->rec_len);
301: }
302: brelse(bh);
303: return NULL;
304: }
305:
306: int ext_create(struct inode * dir,const char * name, int len, int mode,
307: struct inode ** result)
308: {
309: struct inode * inode;
310: struct buffer_head * bh;
311: struct ext_dir_entry * de;
312:
313: *result = NULL;
314: if (!dir)
315: return -ENOENT;
316: inode = ext_new_inode(dir->i_dev);
317: if (!inode) {
318: iput(dir);
319: return -ENOSPC;
320: }
321: inode->i_op = &ext_file_inode_operations;
322: inode->i_mode = mode;
323: inode->i_dirt = 1;
324: bh = ext_add_entry(dir,name,len,&de);
325: if (!bh) {
326: inode->i_nlink--;
327: inode->i_dirt = 1;
328: iput(inode);
329: iput(dir);
330: return -ENOSPC;
331: }
332: de->inode = inode->i_ino;
333: bh->b_dirt = 1;
334: brelse(bh);
335: iput(dir);
336: *result = inode;
337: return 0;
338: }
339:
340: int ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
341: {
342: struct inode * inode;
343: struct buffer_head * bh;
344: struct ext_dir_entry * de;
345:
346: if (!dir)
347: return -ENOENT;
348: bh = ext_find_entry(dir,name,len,&de,NULL,NULL);
349: if (bh) {
350: brelse(bh);
351: iput(dir);
352: return -EEXIST;
353: }
354: inode = ext_new_inode(dir->i_dev);
355: if (!inode) {
356: iput(dir);
357: return -ENOSPC;
358: }
359: inode->i_uid = current->euid;
360: inode->i_mode = mode;
361: inode->i_op = NULL;
362: if (S_ISREG(inode->i_mode))
363: inode->i_op = &ext_file_inode_operations;
364: else if (S_ISDIR(inode->i_mode))
365: inode->i_op = &ext_dir_inode_operations;
366: else if (S_ISLNK(inode->i_mode))
367: inode->i_op = &ext_symlink_inode_operations;
368: else if (S_ISCHR(inode->i_mode))
369: inode->i_op = &ext_chrdev_inode_operations;
370: else if (S_ISBLK(inode->i_mode))
371: inode->i_op = &ext_blkdev_inode_operations;
372: else if (S_ISFIFO(inode->i_mode)) {
373: inode->i_op = &ext_fifo_inode_operations;
374: inode->i_size = 0;
375: inode->i_pipe = 1;
376: PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
377: PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
378: }
379: if (S_ISBLK(mode) || S_ISCHR(mode))
380: inode->i_rdev = rdev;
381: inode->i_mtime = inode->i_atime = CURRENT_TIME;
382: inode->i_dirt = 1;
383: bh = ext_add_entry(dir,name,len,&de);
384: if (!bh) {
385: inode->i_nlink--;
386: inode->i_dirt = 1;
387: iput(inode);
388: iput(dir);
389: return -ENOSPC;
390: }
391: de->inode = inode->i_ino;
392: bh->b_dirt = 1;
393: brelse(bh);
394: iput(dir);
395: iput(inode);
396: return 0;
397: }
398:
399: int ext_mkdir(struct inode * dir, const char * name, int len, int mode)
400: {
401: struct inode * inode;
402: struct buffer_head * bh, *dir_block;
403: struct ext_dir_entry * de;
404:
405: bh = ext_find_entry(dir,name,len,&de,NULL,NULL);
406: if (bh) {
407: brelse(bh);
408: iput(dir);
409: return -EEXIST;
410: }
411: inode = ext_new_inode(dir->i_dev);
412: if (!inode) {
413: iput(dir);
414: return -ENOSPC;
415: }
416: inode->i_op = &ext_dir_inode_operations;
417: inode->i_size = 2 * 16; /* Each entry is coded on 16 bytes for "." and ".."
418: - 4 bytes for the inode number,
419: - 2 bytes for the record length
420: - 2 bytes for the name length
421: - 8 bytes for the name */
422: inode->i_mtime = inode->i_atime = CURRENT_TIME;
423: if (!(inode->i_data[0] = ext_new_block(inode->i_dev))) {
424: iput(dir);
425: inode->i_nlink--;
426: inode->i_dirt = 1;
427: iput(inode);
428: return -ENOSPC;
429: }
430: inode->i_dirt = 1;
431: if (!(dir_block = bread(inode->i_dev,inode->i_data[0]))) {
432: iput(dir);
433: inode->i_nlink--;
434: inode->i_dirt = 1;
435: iput(inode);
436: return -EIO;
437: }
438: de = (struct ext_dir_entry *) dir_block->b_data;
439: de->inode=inode->i_ino;
440: de->rec_len=16;
441: de->name_len=1;
442: strcpy(de->name,".");
443: /* de++; */
444: de = (struct ext_dir_entry *) ((char *) de + de->rec_len);
445: de->inode = dir->i_ino;
446: de->rec_len=16;
447: de->name_len=2;
448: strcpy(de->name,"..");
449: inode->i_nlink = 2;
450: dir_block->b_dirt = 1;
451: brelse(dir_block);
452: inode->i_mode = I_DIRECTORY | (mode & 0777 & ~current->umask);
453: inode->i_dirt = 1;
454: bh = ext_add_entry(dir,name,len,&de);
455: if (!bh) {
456: iput(dir);
457: inode->i_nlink=0;
458: iput(inode);
459: return -ENOSPC;
460: }
461: de->inode = inode->i_ino;
462: bh->b_dirt = 1;
463: dir->i_nlink++;
464: dir->i_dirt = 1;
465: iput(dir);
466: iput(inode);
467: brelse(bh);
468: return 0;
469: }
470:
471: /*
472: * routine to check that the specified directory is empty (for rmdir)
473: */
474: static int empty_dir(struct inode * inode)
475: {
476: int /* nr, */ block;
477: /* int len; */
478: unsigned long offset;
479: struct buffer_head * bh;
480: struct ext_dir_entry * de, * de1;
481:
482: /* len = inode->i_size / sizeof (struct ext_dir_entry); */
483: if (inode->i_size < 2 * 12 || !inode->i_data[0] ||
484: !(bh=bread(inode->i_dev,inode->i_data[0]))) {
485: printk("warning - bad directory on dev %04x\n",inode->i_dev);
486: return 0;
487: }
488: de = (struct ext_dir_entry *) bh->b_data;
489: de1 = (struct ext_dir_entry *) ((char *) de + de->rec_len);
490: if (de->inode != inode->i_ino || !de1->inode ||
491: strcmp(".",de->name) || strcmp("..",de1->name)) {
492: printk("warning - bad directory on dev %04x\n",inode->i_dev);
493: return 0;
494: }
495: /* nr = 2; */
496: offset = de->rec_len + de1->rec_len;
497: de = (struct ext_dir_entry *) ((char *) de1 + de1->rec_len);
498: while (offset < inode->i_size ) {
499: if ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) {
500: brelse(bh);
501: block = ext_bmap(inode, offset >> BLOCK_SIZE_BITS);
502: if (!block) {
503: offset += BLOCK_SIZE;
504: continue;
505: }
506: if (!(bh=bread(inode->i_dev,block)))
507: return 0;
508: de = (struct ext_dir_entry *) bh->b_data;
509: }
510: if (de->inode) {
511: brelse(bh);
512: return 0;
513: }
514: offset += de->rec_len;
515: de = (struct ext_dir_entry *) ((char *) de + de->rec_len);
516: }
517: brelse(bh);
518: return 1;
519: }
520:
521: static inline void ext_merge_entries (struct ext_dir_entry * de,
522: struct ext_dir_entry * pde, struct ext_dir_entry * nde)
523: {
524: if (! nde->inode)
525: de->rec_len += nde->rec_len;
526: if (! pde->inode)
527: pde->rec_len += de->rec_len;
528: }
529:
530: int ext_rmdir(struct inode * dir, const char * name, int len)
531: {
532: int retval;
533: struct inode * inode;
534: struct buffer_head * bh;
535: struct ext_dir_entry * de, * pde, * nde;
536:
537: inode = NULL;
538: bh = ext_find_entry(dir,name,len,&de,&pde,&nde);
539: retval = -ENOENT;
540: if (!bh)
541: goto end_rmdir;
542: retval = -EPERM;
543: if (!(inode = iget(dir->i_dev, de->inode)))
544: goto end_rmdir;
545: if ((dir->i_mode & S_ISVTX) && current->euid &&
546: inode->i_uid != current->euid)
547: goto end_rmdir;
548: if (inode->i_dev != dir->i_dev)
549: goto end_rmdir;
550: if (inode == dir) /* we may not delete ".", but "../dir" is ok */
551: goto end_rmdir;
552: if (!S_ISDIR(inode->i_mode)) {
553: retval = -ENOTDIR;
554: goto end_rmdir;
555: }
556: if (!empty_dir(inode)) {
557: retval = -ENOTEMPTY;
558: goto end_rmdir;
559: }
560: if (inode->i_count > 1) {
561: retval = -EBUSY;
562: goto end_rmdir;
563: }
564: if (inode->i_nlink != 2)
565: printk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
566: de->inode = 0;
567: de->name_len = 0;
568: ext_merge_entries (de, pde, nde);
569: bh->b_dirt = 1;
570: inode->i_nlink=0;
571: inode->i_dirt=1;
572: dir->i_nlink--;
573: dir->i_ctime = dir->i_mtime = CURRENT_TIME;
574: dir->i_dirt=1;
575: retval = 0;
576: end_rmdir:
577: iput(dir);
578: iput(inode);
579: brelse(bh);
580: return retval;
581: }
582:
583: int ext_unlink(struct inode * dir, const char * name, int len)
584: {
585: int retval;
586: struct inode * inode;
587: struct buffer_head * bh;
588: struct ext_dir_entry * de, * pde, * nde;
589:
590: retval = -ENOENT;
591: inode = NULL;
592: bh = ext_find_entry(dir,name,len,&de,&pde,&nde);
593: if (!bh)
594: goto end_unlink;
595: if (!(inode = iget(dir->i_dev, de->inode)))
596: goto end_unlink;
597: retval = -EPERM;
598: if ((dir->i_mode & S_ISVTX) && !suser() &&
599: current->euid != inode->i_uid &&
600: current->euid != dir->i_uid)
601: goto end_unlink;
602: if (S_ISDIR(inode->i_mode))
603: goto end_unlink;
604: if (!inode->i_nlink) {
605: printk("Deleting nonexistent file (%04x:%d), %d\n",
606: inode->i_dev,inode->i_ino,inode->i_nlink);
607: inode->i_nlink=1;
608: }
609: de->inode = 0;
610: de->name_len = 0;
611: ext_merge_entries (de, pde, nde);
612: bh->b_dirt = 1;
613: inode->i_nlink--;
614: inode->i_dirt = 1;
615: inode->i_ctime = CURRENT_TIME;
616: retval = 0;
617: end_unlink:
618: brelse(bh);
619: iput(inode);
620: iput(dir);
621: return retval;
622: }
623:
624: int ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
625: {
626: struct ext_dir_entry * de;
627: struct inode * inode = NULL;
628: struct buffer_head * bh = NULL, * name_block = NULL;
629: int i;
630: char c;
631:
632: if (!(inode = ext_new_inode(dir->i_dev))) {
633: iput(dir);
634: return -ENOSPC;
635: }
636: inode->i_mode = S_IFLNK | 0777;
637: inode->i_op = &ext_symlink_inode_operations;
638: if (!(inode->i_data[0] = ext_new_block(inode->i_dev))) {
639: iput(dir);
640: inode->i_nlink--;
641: inode->i_dirt = 1;
642: iput(inode);
643: return -ENOSPC;
644: }
645: inode->i_dirt = 1;
646: if (!(name_block = bread(inode->i_dev,inode->i_data[0]))) {
647: iput(dir);
648: inode->i_nlink--;
649: inode->i_dirt = 1;
650: iput(inode);
651: return -EIO;
652: }
653: i = 0;
654: while (i < 1023 && (c=get_fs_byte(symname++)))
655: name_block->b_data[i++] = c;
656: name_block->b_data[i] = 0;
657: name_block->b_dirt = 1;
658: brelse(name_block);
659: inode->i_size = i;
660: inode->i_dirt = 1;
661: bh = ext_find_entry(dir,name,len,&de,NULL,NULL);
662: if (bh) {
663: inode->i_nlink--;
664: inode->i_dirt = 1;
665: iput(inode);
666: brelse(bh);
667: iput(dir);
668: return -EEXIST;
669: }
670: bh = ext_add_entry(dir,name,len,&de);
671: if (!bh) {
672: inode->i_nlink--;
673: inode->i_dirt = 1;
674: iput(inode);
675: iput(dir);
676: return -ENOSPC;
677: }
678: de->inode = inode->i_ino;
679: bh->b_dirt = 1;
680: brelse(bh);
681: iput(dir);
682: iput(inode);
683: return 0;
684: }
685:
686: int ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
687: {
688: struct ext_dir_entry * de;
689: struct buffer_head * bh;
690:
691: if (S_ISDIR(oldinode->i_mode)) {
692: iput(oldinode);
693: iput(dir);
694: return -EPERM;
695: }
696: bh = ext_find_entry(dir,name,len,&de,NULL,NULL);
697: if (bh) {
698: brelse(bh);
699: iput(dir);
700: iput(oldinode);
701: return -EEXIST;
702: }
703: bh = ext_add_entry(dir,name,len,&de);
704: if (!bh) {
705: iput(dir);
706: iput(oldinode);
707: return -ENOSPC;
708: }
709: de->inode = oldinode->i_ino;
710: bh->b_dirt = 1;
711: brelse(bh);
712: iput(dir);
713: oldinode->i_nlink++;
714: oldinode->i_ctime = CURRENT_TIME;
715: oldinode->i_dirt = 1;
716: iput(oldinode);
717: return 0;
718: }
719:
720: static int subdir(struct inode * new, struct inode * old)
721: {
722: unsigned short fs;
723: int ino;
724: int result;
725:
726: __asm__("mov %%fs,%0":"=r" (fs));
727: __asm__("mov %0,%%fs"::"r" ((unsigned short) 0x10));
728: new->i_count++;
729: result = 0;
730: for (;;) {
731: if (new == old) {
732: result = 1;
733: break;
734: }
735: if (new->i_dev != old->i_dev)
736: break;
737: ino = new->i_ino;
738: if (ext_lookup(new,"..",2,&new))
739: break;
740: if (new->i_ino == ino)
741: break;
742: }
743: iput(new);
744: __asm__("mov %0,%%fs"::"r" (fs));
745: return result;
746: }
747:
748: #define PARENT_INO(buffer) \
749: ((struct ext_dir_entry *) ((char *) buffer + \
750: ((struct ext_dir_entry *) buffer)->rec_len))->inode
751: /* (((struct ext_dir_entry *) (buffer))[1].inode) */
752:
753: #define PARENT_NAME(buffer) \
754: ((struct ext_dir_entry *) ((char *) buffer + \
755: ((struct ext_dir_entry *) buffer)->rec_len))->name
756: /* (((struct ext_dir_entry *) (buffer))[1].name) */
757:
758: /*
759: * rename uses retrying to avoid race-conditions: at least they should be minimal.
760: * it tries to allocate all the blocks, then sanity-checks, and if the sanity-
761: * checks fail, it tries to restart itself again. Very practical - no changes
762: * are done until we know everything works ok.. and then all the changes can be
763: * done in one fell swoop when we have claimed all the buffers needed.
764: *
765: * Anybody can rename anything with this: the permission checks are left to the
766: * higher-level routines.
767: */
768: static int do_ext_rename(struct inode * old_dir, const char * old_name, int old_len,
769: struct inode * new_dir, const char * new_name, int new_len)
770: {
771: struct inode * old_inode, * new_inode;
772: struct buffer_head * old_bh, * new_bh, * dir_bh;
773: struct ext_dir_entry * old_de, * new_de, * pde, * nde;
774: int retval;
775:
776: goto start_up;
777: try_again:
778: brelse(old_bh);
779: brelse(new_bh);
780: brelse(dir_bh);
781: iput(old_inode);
782: iput(new_inode);
783: current->counter = 0;
784: schedule();
785: start_up:
786: old_inode = new_inode = NULL;
787: old_bh = new_bh = dir_bh = NULL;
788: old_bh = ext_find_entry(old_dir,old_name,old_len,&old_de,&pde,&nde);
789: retval = -ENOENT;
790: if (!old_bh)
791: goto end_rename;
792: old_inode = iget(old_dir->i_dev, old_de->inode);
793: if (!old_inode)
794: goto end_rename;
795: if ((old_dir->i_mode & S_ISVTX) &&
796: current->euid != old_inode->i_uid &&
797: current->euid != old_dir->i_uid && !suser())
798: goto end_rename;
799: new_bh = ext_find_entry(new_dir,new_name,new_len,&new_de,NULL,NULL);
800: if (new_bh) {
801: new_inode = iget(new_dir->i_dev, new_de->inode);
802: if (!new_inode) {
803: brelse(new_bh);
804: new_bh = NULL;
805: }
806: }
807: if (new_inode == old_inode) {
808: retval = 0;
809: goto end_rename;
810: }
811: if (S_ISDIR(old_inode->i_mode)) {
812: retval = -EEXIST;
813: if (new_bh)
814: goto end_rename;
815: retval = -EACCES;
816: if (!permission(old_inode, MAY_WRITE))
817: goto end_rename;
818: retval = -EINVAL;
819: if (subdir(new_dir, old_inode))
820: goto end_rename;
821: retval = -EIO;
822: if (!old_inode->i_data[0])
823: goto end_rename;
824: if (!(dir_bh = bread(old_inode->i_dev, old_inode->i_data[0])))
825: goto end_rename;
826: if (PARENT_INO(dir_bh->b_data) != old_dir->i_ino)
827: goto end_rename;
828: }
829: if (!new_bh)
830: new_bh = ext_add_entry(new_dir,new_name,new_len,&new_de);
831: retval = -ENOSPC;
832: if (!new_bh)
833: goto end_rename;
834: /* sanity checking before doing the rename - avoid races */
835: if (new_inode && (new_de->inode != new_inode->i_ino))
836: goto try_again;
837: if (new_de->inode && !new_inode)
838: goto try_again;
839: if (old_de->inode != old_inode->i_ino)
840: goto try_again;
841: /* ok, that's it */
842: old_de->inode = 0;
843: old_de->name_len = 0;
844: ext_merge_entries (old_de, pde, nde);
845: new_de->inode = old_inode->i_ino;
846: if (new_inode) {
847: new_inode->i_nlink--;
848: new_inode->i_dirt = 1;
849: }
850: old_bh->b_dirt = 1;
851: new_bh->b_dirt = 1;
852: if (dir_bh) {
853: PARENT_INO(dir_bh->b_data) = new_dir->i_ino;
854: dir_bh->b_dirt = 1;
855: old_dir->i_nlink--;
856: new_dir->i_nlink++;
857: old_dir->i_dirt = 1;
858: new_dir->i_dirt = 1;
859: }
860: retval = 0;
861: end_rename:
862: brelse(dir_bh);
863: brelse(old_bh);
864: brelse(new_bh);
865: iput(old_inode);
866: iput(new_inode);
867: iput(old_dir);
868: iput(new_dir);
869: return retval;
870: }
871:
872: /*
873: * Ok, rename also locks out other renames, as they can change the parent of
874: * a directory, and we don't want any races. Other races are checked for by
875: * "do_rename()", which restarts if there are inconsistencies.
876: *
877: * Note that there is no race between different filesystems: it's only within
878: * the same device that races occur: many renames can happen at once, as long
879: * as they are on different partitions.
880: */
881: int ext_rename(struct inode * old_dir, const char * old_name, int old_len,
882: struct inode * new_dir, const char * new_name, int new_len)
883: {
884: static struct task_struct * wait = NULL;
885: static int lock = 0;
886: int result;
887:
888: while (lock)
889: sleep_on(&wait);
890: lock = 1;
891: result = do_ext_rename(old_dir, old_name, old_len,
892: new_dir, new_name, new_len);
893: lock = 0;
894: wake_up(&wait);
895: return result;
896: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.