dir_fplus.c 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179
  1. /*
  2. * linux/fs/adfs/dir_fplus.c
  3. *
  4. * Copyright (C) 1997-1999 Russell King
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. */
  10. #include <linux/errno.h>
  11. #include <linux/fs.h>
  12. #include <linux/adfs_fs.h>
  13. #include <linux/time.h>
  14. #include <linux/stat.h>
  15. #include <linux/spinlock.h>
  16. #include <linux/buffer_head.h>
  17. #include <linux/string.h>
  18. #include "adfs.h"
  19. #include "dir_fplus.h"
  20. static int
  21. adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir)
  22. {
  23. struct adfs_bigdirheader *h;
  24. struct adfs_bigdirtail *t;
  25. unsigned long block;
  26. unsigned int blk, size;
  27. int i, ret = -EIO;
  28. dir->nr_buffers = 0;
  29. block = __adfs_block_map(sb, id, 0);
  30. if (!block) {
  31. adfs_error(sb, "dir object %X has a hole at offset 0", id);
  32. goto out;
  33. }
  34. dir->bh[0] = sb_bread(sb, block);
  35. if (!dir->bh[0])
  36. goto out;
  37. dir->nr_buffers += 1;
  38. h = (struct adfs_bigdirheader *)dir->bh[0]->b_data;
  39. size = le32_to_cpu(h->bigdirsize);
  40. if (size != sz) {
  41. printk(KERN_WARNING "adfs: adfs_fplus_read: directory header size\n"
  42. " does not match directory size\n");
  43. }
  44. if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 ||
  45. h->bigdirversion[2] != 0 || size & 2047 ||
  46. h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME))
  47. goto out;
  48. size >>= sb->s_blocksize_bits;
  49. for (blk = 1; blk < size; blk++) {
  50. block = __adfs_block_map(sb, id, blk);
  51. if (!block) {
  52. adfs_error(sb, "dir object %X has a hole at offset %d", id, blk);
  53. goto out;
  54. }
  55. dir->bh[blk] = sb_bread(sb, block);
  56. if (!dir->bh[blk])
  57. goto out;
  58. dir->nr_buffers = blk;
  59. }
  60. t = (struct adfs_bigdirtail *)(dir->bh[size - 1]->b_data + (sb->s_blocksize - 8));
  61. if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) ||
  62. t->bigdirendmasseq != h->startmasseq ||
  63. t->reserved[0] != 0 || t->reserved[1] != 0)
  64. goto out;
  65. dir->parent_id = le32_to_cpu(h->bigdirparent);
  66. dir->sb = sb;
  67. return 0;
  68. out:
  69. for (i = 0; i < dir->nr_buffers; i++)
  70. brelse(dir->bh[i]);
  71. dir->sb = NULL;
  72. return ret;
  73. }
  74. static int
  75. adfs_fplus_setpos(struct adfs_dir *dir, unsigned int fpos)
  76. {
  77. struct adfs_bigdirheader *h = (struct adfs_bigdirheader *)dir->bh[0]->b_data;
  78. int ret = -ENOENT;
  79. if (fpos <= le32_to_cpu(h->bigdirentries)) {
  80. dir->pos = fpos;
  81. ret = 0;
  82. }
  83. return ret;
  84. }
  85. static void
  86. dir_memcpy(struct adfs_dir *dir, unsigned int offset, void *to, int len)
  87. {
  88. struct super_block *sb = dir->sb;
  89. unsigned int buffer, partial, remainder;
  90. buffer = offset >> sb->s_blocksize_bits;
  91. offset &= sb->s_blocksize - 1;
  92. partial = sb->s_blocksize - offset;
  93. if (partial >= len)
  94. memcpy(to, dir->bh[buffer]->b_data + offset, len);
  95. else {
  96. char *c = (char *)to;
  97. remainder = len - partial;
  98. memcpy(c, dir->bh[buffer]->b_data + offset, partial);
  99. memcpy(c + partial, dir->bh[buffer + 1]->b_data, remainder);
  100. }
  101. }
  102. static int
  103. adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj)
  104. {
  105. struct adfs_bigdirheader *h = (struct adfs_bigdirheader *)dir->bh[0]->b_data;
  106. struct adfs_bigdirentry bde;
  107. unsigned int offset;
  108. int i, ret = -ENOENT;
  109. if (dir->pos >= le32_to_cpu(h->bigdirentries))
  110. goto out;
  111. offset = offsetof(struct adfs_bigdirheader, bigdirname);
  112. offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
  113. offset += dir->pos * sizeof(struct adfs_bigdirentry);
  114. dir_memcpy(dir, offset, &bde, sizeof(struct adfs_bigdirentry));
  115. obj->loadaddr = le32_to_cpu(bde.bigdirload);
  116. obj->execaddr = le32_to_cpu(bde.bigdirexec);
  117. obj->size = le32_to_cpu(bde.bigdirlen);
  118. obj->file_id = le32_to_cpu(bde.bigdirindaddr);
  119. obj->attr = le32_to_cpu(bde.bigdirattr);
  120. obj->name_len = le32_to_cpu(bde.bigdirobnamelen);
  121. offset = offsetof(struct adfs_bigdirheader, bigdirname);
  122. offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
  123. offset += le32_to_cpu(h->bigdirentries) * sizeof(struct adfs_bigdirentry);
  124. offset += le32_to_cpu(bde.bigdirobnameptr);
  125. dir_memcpy(dir, offset, obj->name, obj->name_len);
  126. for (i = 0; i < obj->name_len; i++)
  127. if (obj->name[i] == '/')
  128. obj->name[i] = '.';
  129. dir->pos += 1;
  130. ret = 0;
  131. out:
  132. return ret;
  133. }
  134. static void
  135. adfs_fplus_free(struct adfs_dir *dir)
  136. {
  137. int i;
  138. for (i = 0; i < dir->nr_buffers; i++)
  139. brelse(dir->bh[i]);
  140. dir->sb = NULL;
  141. }
  142. struct adfs_dir_ops adfs_fplus_dir_ops = {
  143. .read = adfs_fplus_read,
  144. .setpos = adfs_fplus_setpos,
  145. .getnext = adfs_fplus_getnext,
  146. .free = adfs_fplus_free
  147. };