~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/adfs/dir_fplus.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  *  linux/fs/adfs/dir_fplus.c
  4  *
  5  *  Copyright (C) 1997-1999 Russell King
  6  */
  7 #include <linux/slab.h>
  8 #include "adfs.h"
  9 #include "dir_fplus.h"
 10 
 11 static int
 12 adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir)
 13 {
 14         struct adfs_bigdirheader *h;
 15         struct adfs_bigdirtail *t;
 16         unsigned long block;
 17         unsigned int blk, size;
 18         int i, ret = -EIO;
 19 
 20         dir->nr_buffers = 0;
 21 
 22         /* start off using fixed bh set - only alloc for big dirs */
 23         dir->bh_fplus = &dir->bh[0];
 24 
 25         block = __adfs_block_map(sb, id, 0);
 26         if (!block) {
 27                 adfs_error(sb, "dir object %X has a hole at offset 0", id);
 28                 goto out;
 29         }
 30 
 31         dir->bh_fplus[0] = sb_bread(sb, block);
 32         if (!dir->bh_fplus[0])
 33                 goto out;
 34         dir->nr_buffers += 1;
 35 
 36         h = (struct adfs_bigdirheader *)dir->bh_fplus[0]->b_data;
 37         size = le32_to_cpu(h->bigdirsize);
 38         if (size != sz) {
 39                 adfs_msg(sb, KERN_WARNING,
 40                          "directory header size %X does not match directory size %X",
 41                          size, sz);
 42         }
 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                 adfs_error(sb, "dir %06x has malformed header", id);
 48                 goto out;
 49         }
 50 
 51         size >>= sb->s_blocksize_bits;
 52         if (size > ARRAY_SIZE(dir->bh)) {
 53                 /* this directory is too big for fixed bh set, must allocate */
 54                 struct buffer_head **bh_fplus =
 55                         kcalloc(size, sizeof(struct buffer_head *),
 56                                 GFP_KERNEL);
 57                 if (!bh_fplus) {
 58                         adfs_msg(sb, KERN_ERR,
 59                                  "not enough memory for dir object %X (%d blocks)",
 60                                  id, size);
 61                         ret = -ENOMEM;
 62                         goto out;
 63                 }
 64                 dir->bh_fplus = bh_fplus;
 65                 /* copy over the pointer to the block that we've already read */
 66                 dir->bh_fplus[0] = dir->bh[0];
 67         }
 68 
 69         for (blk = 1; blk < size; blk++) {
 70                 block = __adfs_block_map(sb, id, blk);
 71                 if (!block) {
 72                         adfs_error(sb, "dir object %X has a hole at offset %d", id, blk);
 73                         goto out;
 74                 }
 75 
 76                 dir->bh_fplus[blk] = sb_bread(sb, block);
 77                 if (!dir->bh_fplus[blk]) {
 78                         adfs_error(sb,  "dir object %x failed read for offset %d, mapped block %lX",
 79                                    id, blk, block);
 80                         goto out;
 81                 }
 82 
 83                 dir->nr_buffers += 1;
 84         }
 85 
 86         t = (struct adfs_bigdirtail *)
 87                 (dir->bh_fplus[size - 1]->b_data + (sb->s_blocksize - 8));
 88 
 89         if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) ||
 90             t->bigdirendmasseq != h->startmasseq ||
 91             t->reserved[0] != 0 || t->reserved[1] != 0) {
 92                 adfs_error(sb, "dir %06x has malformed tail", id);
 93                 goto out;
 94         }
 95 
 96         dir->parent_id = le32_to_cpu(h->bigdirparent);
 97         dir->sb = sb;
 98         return 0;
 99 
100 out:
101         if (dir->bh_fplus) {
102                 for (i = 0; i < dir->nr_buffers; i++)
103                         brelse(dir->bh_fplus[i]);
104 
105                 if (&dir->bh[0] != dir->bh_fplus)
106                         kfree(dir->bh_fplus);
107 
108                 dir->bh_fplus = NULL;
109         }
110 
111         dir->nr_buffers = 0;
112         dir->sb = NULL;
113         return ret;
114 }
115 
116 static int
117 adfs_fplus_setpos(struct adfs_dir *dir, unsigned int fpos)
118 {
119         struct adfs_bigdirheader *h =
120                 (struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
121         int ret = -ENOENT;
122 
123         if (fpos <= le32_to_cpu(h->bigdirentries)) {
124                 dir->pos = fpos;
125                 ret = 0;
126         }
127 
128         return ret;
129 }
130 
131 static void
132 dir_memcpy(struct adfs_dir *dir, unsigned int offset, void *to, int len)
133 {
134         struct super_block *sb = dir->sb;
135         unsigned int buffer, partial, remainder;
136 
137         buffer = offset >> sb->s_blocksize_bits;
138         offset &= sb->s_blocksize - 1;
139 
140         partial = sb->s_blocksize - offset;
141 
142         if (partial >= len)
143                 memcpy(to, dir->bh_fplus[buffer]->b_data + offset, len);
144         else {
145                 char *c = (char *)to;
146 
147                 remainder = len - partial;
148 
149                 memcpy(c,
150                         dir->bh_fplus[buffer]->b_data + offset,
151                         partial);
152 
153                 memcpy(c + partial,
154                         dir->bh_fplus[buffer + 1]->b_data,
155                         remainder);
156         }
157 }
158 
159 static int
160 adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj)
161 {
162         struct adfs_bigdirheader *h =
163                 (struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
164         struct adfs_bigdirentry bde;
165         unsigned int offset;
166         int ret = -ENOENT;
167 
168         if (dir->pos >= le32_to_cpu(h->bigdirentries))
169                 goto out;
170 
171         offset = offsetof(struct adfs_bigdirheader, bigdirname);
172         offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
173         offset += dir->pos * sizeof(struct adfs_bigdirentry);
174 
175         dir_memcpy(dir, offset, &bde, sizeof(struct adfs_bigdirentry));
176 
177         obj->loadaddr = le32_to_cpu(bde.bigdirload);
178         obj->execaddr = le32_to_cpu(bde.bigdirexec);
179         obj->size     = le32_to_cpu(bde.bigdirlen);
180         obj->indaddr  = le32_to_cpu(bde.bigdirindaddr);
181         obj->attr     = le32_to_cpu(bde.bigdirattr);
182         obj->name_len = le32_to_cpu(bde.bigdirobnamelen);
183 
184         offset = offsetof(struct adfs_bigdirheader, bigdirname);
185         offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
186         offset += le32_to_cpu(h->bigdirentries) * sizeof(struct adfs_bigdirentry);
187         offset += le32_to_cpu(bde.bigdirobnameptr);
188 
189         dir_memcpy(dir, offset, obj->name, obj->name_len);
190         adfs_object_fixup(dir, obj);
191 
192         dir->pos += 1;
193         ret = 0;
194 out:
195         return ret;
196 }
197 
198 static int
199 adfs_fplus_sync(struct adfs_dir *dir)
200 {
201         int err = 0;
202         int i;
203 
204         for (i = dir->nr_buffers - 1; i >= 0; i--) {
205                 struct buffer_head *bh = dir->bh_fplus[i];
206                 sync_dirty_buffer(bh);
207                 if (buffer_req(bh) && !buffer_uptodate(bh))
208                         err = -EIO;
209         }
210 
211         return err;
212 }
213 
214 static void
215 adfs_fplus_free(struct adfs_dir *dir)
216 {
217         int i;
218 
219         if (dir->bh_fplus) {
220                 for (i = 0; i < dir->nr_buffers; i++)
221                         brelse(dir->bh_fplus[i]);
222 
223                 if (&dir->bh[0] != dir->bh_fplus)
224                         kfree(dir->bh_fplus);
225 
226                 dir->bh_fplus = NULL;
227         }
228 
229         dir->nr_buffers = 0;
230         dir->sb = NULL;
231 }
232 
233 const struct adfs_dir_ops adfs_fplus_dir_ops = {
234         .read           = adfs_fplus_read,
235         .setpos         = adfs_fplus_setpos,
236         .getnext        = adfs_fplus_getnext,
237         .sync           = adfs_fplus_sync,
238         .free           = adfs_fplus_free
239 };
240 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp