projects/linux·blob master · refs

398 lines · 9.0 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright 2017 Omnibond Systems, L.L.C.
4 */
5
6#include <linux/filelock.h>
7#include "protocol.h"
8#include "orangefs-kernel.h"
9#include "orangefs-bufmap.h"
10
11struct orangefs_dir_part {
12 struct orangefs_dir_part *next;
13 size_t len;
14};
15
16struct orangefs_dir {
17 __u64 token;
18 struct orangefs_dir_part *part;
19 loff_t end;
20 int error;
21};
22
23#define PART_SHIFT (24)
24#define PART_SIZE (1<<24)
25#define PART_MASK (~(PART_SIZE - 1))
26
27/*
28 * There can be up to 512 directory entries. Each entry is encoded as
29 * follows:
30 * 4 bytes: string size (n)
31 * n bytes: string
32 * 1 byte: trailing zero
33 * padding to 8 bytes
34 * 16 bytes: khandle
35 * padding to 8 bytes
36 *
37 * The trailer_buf starts with a struct orangefs_readdir_response_s
38 * which must be skipped to get to the directory data.
39 *
40 * The data which is received from the userspace daemon is termed a
41 * part and is stored in a linked list in case more than one part is
42 * needed for a large directory.
43 *
44 * The position pointer (ctx->pos) encodes the part and offset on which
45 * to begin reading at. Bits above PART_SHIFT encode the part and bits
46 * below PART_SHIFT encode the offset. Parts are stored in a linked
47 * list which grows as data is received from the server. The overhead
48 * associated with managing the list is presumed to be small compared to
49 * the overhead of communicating with the server.
50 *
51 * As data is received from the server, it is placed at the end of the
52 * part list. Data is parsed from the current position as it is needed.
53 * When data is determined to be corrupt, it is either because the
54 * userspace component has sent back corrupt data or because the file
55 * pointer has been moved to an invalid location. Since the two cannot
56 * be differentiated, return EIO.
57 *
58 * Part zero is synthesized to contains `.' and `..'. Part one is the
59 * first part of the part list.
60 */
61
62static int do_readdir(struct orangefs_dir *od, struct inode *inode,
63 struct orangefs_kernel_op_s *op)
64{
65 struct orangefs_inode_s *oi = ORANGEFS_I(inode);
66 struct orangefs_readdir_response_s *resp;
67 int bufi, r;
68
69 /*
70 * Despite the badly named field, readdir does not use shared
71 * memory. However, there are a limited number of readdir
72 * slots, which must be allocated here. This flag simply tells
73 * the op scheduler to return the op here for retry.
74 */
75 op->uses_shared_memory = 1;
76 op->upcall.req.readdir.refn = oi->refn;
77 op->upcall.req.readdir.token = od->token;
78 op->upcall.req.readdir.max_dirent_count =
79 ORANGEFS_MAX_DIRENT_COUNT_READDIR;
80
81again:
82 bufi = orangefs_readdir_index_get();
83 if (bufi < 0) {
84 od->error = bufi;
85 return bufi;
86 }
87
88 op->upcall.req.readdir.buf_index = bufi;
89
90 r = service_operation(op, "orangefs_readdir",
91 get_interruptible_flag(inode));
92
93 orangefs_readdir_index_put(bufi);
94
95 if (op_state_purged(op)) {
96 if (r == -EAGAIN) {
97 vfree(op->downcall.trailer_buf);
98 goto again;
99 } else if (r == -EIO) {
100 vfree(op->downcall.trailer_buf);
101 od->error = r;
102 return r;
103 }
104 }
105
106 if (r < 0) {
107 vfree(op->downcall.trailer_buf);
108 od->error = r;
109 return r;
110 } else if (op->downcall.status) {
111 vfree(op->downcall.trailer_buf);
112 od->error = op->downcall.status;
113 return op->downcall.status;
114 }
115
116 /*
117 * The maximum size is size per entry times the 512 entries plus
118 * the header. This is well under the limit.
119 */
120 if (op->downcall.trailer_size > PART_SIZE) {
121 vfree(op->downcall.trailer_buf);
122 od->error = -EIO;
123 return -EIO;
124 }
125
126 resp = (struct orangefs_readdir_response_s *)
127 op->downcall.trailer_buf;
128 od->token = resp->token;
129 return 0;
130}
131
132static int parse_readdir(struct orangefs_dir *od,
133 struct orangefs_kernel_op_s *op)
134{
135 struct orangefs_dir_part *part, *new;
136 size_t count;
137
138 count = 1;
139 part = od->part;
140 while (part) {
141 count++;
142 if (part->next)
143 part = part->next;
144 else
145 break;
146 }
147
148 new = (void *)op->downcall.trailer_buf;
149 new->next = NULL;
150 new->len = op->downcall.trailer_size -
151 sizeof(struct orangefs_readdir_response_s);
152 if (!od->part)
153 od->part = new;
154 else
155 part->next = new;
156 count++;
157 od->end = count << PART_SHIFT;
158
159 return 0;
160}
161
162static int orangefs_dir_more(struct orangefs_dir *od, struct inode *inode)
163{
164 struct orangefs_kernel_op_s *op;
165 int r;
166
167 op = op_alloc(ORANGEFS_VFS_OP_READDIR);
168 if (!op) {
169 od->error = -ENOMEM;
170 return -ENOMEM;
171 }
172 r = do_readdir(od, inode, op);
173 if (r) {
174 od->error = r;
175 goto out;
176 }
177 r = parse_readdir(od, op);
178 if (r) {
179 od->error = r;
180 goto out;
181 }
182
183 od->error = 0;
184out:
185 op_release(op);
186 return od->error;
187}
188
189static int fill_from_part(struct orangefs_dir_part *part,
190 struct dir_context *ctx)
191{
192 const int offset = sizeof(struct orangefs_readdir_response_s);
193 struct orangefs_khandle *khandle;
194 __u32 *len;
195 u64 padlen;
196 loff_t i;
197 char *s;
198 i = ctx->pos & ~PART_MASK;
199
200 /* The file offset from userspace is too large. */
201 if (i > part->len)
202 return 1;
203
204 /*
205 * If the seek pointer is positioned just before an entry it
206 * should find the next entry.
207 */
208 if (i % 8)
209 i = i + (8 - i%8)%8;
210
211 while (i < part->len) {
212 if (part->len < i + sizeof *len)
213 break;
214 len = (void *)part + offset + i;
215 /*
216 * len is the size of the string itself. padlen is the
217 * total size of the encoded string.
218 */
219 padlen = (u64)sizeof *len + *len + 1;
220 padlen += (8 - padlen % 8) % 8;
221 if (part->len < i + padlen + sizeof *khandle)
222 goto next;
223 s = (void *)part + offset + i + sizeof *len;
224 if (s[*len] != 0)
225 goto next;
226 khandle = (void *)part + offset + i + padlen;
227 if (!dir_emit(ctx, s, *len,
228 orangefs_khandle_to_ino(khandle),
229 DT_UNKNOWN))
230 return 0;
231 i += padlen + sizeof *khandle;
232 i = i + (8 - i%8)%8;
233 BUG_ON(i > part->len);
234 ctx->pos = (ctx->pos & PART_MASK) | i;
235 continue;
236next:
237 i += 8;
238 }
239 return 1;
240}
241
242static int orangefs_dir_fill(struct orangefs_dir *od, struct dir_context *ctx)
243{
244 struct orangefs_dir_part *part;
245 size_t count;
246
247 count = ((ctx->pos & PART_MASK) >> PART_SHIFT) - 1;
248
249 part = od->part;
250 while (part->next && count) {
251 count--;
252 part = part->next;
253 }
254 /* This means the userspace file offset is invalid. */
255 if (count) {
256 od->error = -EIO;
257 return -EIO;
258 }
259
260 while (part && part->len) {
261 int r;
262 r = fill_from_part(part, ctx);
263 if (r < 0) {
264 od->error = r;
265 return r;
266 } else if (r == 0) {
267 /* Userspace buffer is full. */
268 break;
269 } else {
270 /*
271 * The part ran out of data. Move to the next
272 * part. */
273 ctx->pos = (ctx->pos & PART_MASK) +
274 (1 << PART_SHIFT);
275 part = part->next;
276 }
277 }
278 return 0;
279}
280
281static loff_t orangefs_dir_llseek(struct file *file, loff_t offset,
282 int whence)
283{
284 struct orangefs_dir *od = file->private_data;
285 /*
286 * Delete the stored data so userspace sees new directory
287 * entries.
288 */
289 if (!whence && offset < od->end) {
290 struct orangefs_dir_part *part = od->part;
291 while (part) {
292 struct orangefs_dir_part *next = part->next;
293 vfree(part);
294 part = next;
295 }
296 od->token = ORANGEFS_ITERATE_START;
297 od->part = NULL;
298 od->end = 1 << PART_SHIFT;
299 }
300 return default_llseek(file, offset, whence);
301}
302
303static int orangefs_dir_iterate(struct file *file,
304 struct dir_context *ctx)
305{
306 struct orangefs_dir *od = file->private_data;
307 struct inode *inode = file_inode(file);
308 int r;
309
310 if (od->error)
311 return od->error;
312
313 if (ctx->pos == 0) {
314 if (!dir_emit_dot(file, ctx))
315 return 0;
316 ctx->pos++;
317 }
318 if (ctx->pos == 1) {
319 if (!dir_emit_dotdot(file, ctx))
320 return 0;
321 ctx->pos = 1 << PART_SHIFT;
322 }
323
324 /*
325 * The seek position is in the first synthesized part but is not
326 * valid.
327 */
328 if ((ctx->pos & PART_MASK) == 0)
329 return -EIO;
330
331 r = 0;
332
333 /*
334 * Must read more if the user has sought past what has been read
335 * so far. Stop a user who has sought past the end.
336 */
337 while (od->token != ORANGEFS_ITERATE_END &&
338 ctx->pos > od->end) {
339 r = orangefs_dir_more(od, inode);
340 if (r)
341 return r;
342 }
343 if (od->token == ORANGEFS_ITERATE_END && ctx->pos > od->end)
344 return -EIO;
345
346 /* Then try to fill if there's any left in the buffer. */
347 if (ctx->pos < od->end) {
348 r = orangefs_dir_fill(od, ctx);
349 if (r)
350 return r;
351 }
352
353 /* Finally get some more and try to fill. */
354 if (od->token != ORANGEFS_ITERATE_END) {
355 r = orangefs_dir_more(od, inode);
356 if (r)
357 return r;
358 r = orangefs_dir_fill(od, ctx);
359 }
360
361 return r;
362}
363
364static int orangefs_dir_open(struct inode *inode, struct file *file)
365{
366 struct orangefs_dir *od;
367 file->private_data = kmalloc_obj(struct orangefs_dir);
368 if (!file->private_data)
369 return -ENOMEM;
370 od = file->private_data;
371 od->token = ORANGEFS_ITERATE_START;
372 od->part = NULL;
373 od->end = 1 << PART_SHIFT;
374 od->error = 0;
375 return 0;
376}
377
378static int orangefs_dir_release(struct inode *inode, struct file *file)
379{
380 struct orangefs_dir *od = file->private_data;
381 struct orangefs_dir_part *part = od->part;
382 while (part) {
383 struct orangefs_dir_part *next = part->next;
384 vfree(part);
385 part = next;
386 }
387 kfree(od);
388 return 0;
389}
390
391const struct file_operations orangefs_dir_operations = {
392 .llseek = orangefs_dir_llseek,
393 .read = generic_read_dir,
394 .iterate_shared = orangefs_dir_iterate,
395 .open = orangefs_dir_open,
396 .release = orangefs_dir_release,
397 .setlease = generic_setlease,
398};