1/*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2018 Miklos Szeredi <miklos@szeredi.hu>
4
5 This program can be distributed under the terms of the GNU GPL.
6 See the file COPYING.
7*/
8
9
10#include "fuse_i.h"
11#include <linux/iversion.h>
12#include <linux/posix_acl.h>
13#include <linux/pagemap.h>
14#include <linux/highmem.h>
15
16static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
17{
18 struct fuse_conn *fc = get_fuse_conn(inode: dir);
19 struct fuse_inode *fi = get_fuse_inode(inode: dir);
20
21 if (!fc->do_readdirplus)
22 return false;
23 if (!fc->readdirplus_auto)
24 return true;
25 if (test_and_clear_bit(nr: FUSE_I_ADVISE_RDPLUS, addr: &fi->state))
26 return true;
27 if (ctx->pos == 0)
28 return true;
29 return false;
30}
31
32static void fuse_add_dirent_to_cache(struct file *file,
33 struct fuse_dirent *dirent, loff_t pos)
34{
35 struct fuse_inode *fi = get_fuse_inode(inode: file_inode(f: file));
36 size_t reclen = FUSE_DIRENT_SIZE(dirent);
37 pgoff_t index;
38 struct page *page;
39 loff_t size;
40 u64 version;
41 unsigned int offset;
42 void *addr;
43
44 spin_lock(lock: &fi->rdc.lock);
45 /*
46 * Is cache already completed? Or this entry does not go at the end of
47 * cache?
48 */
49 if (fi->rdc.cached || pos != fi->rdc.pos) {
50 spin_unlock(lock: &fi->rdc.lock);
51 return;
52 }
53 version = fi->rdc.version;
54 size = fi->rdc.size;
55 offset = size & ~PAGE_MASK;
56 index = size >> PAGE_SHIFT;
57 /* Dirent doesn't fit in current page? Jump to next page. */
58 if (offset + reclen > PAGE_SIZE) {
59 index++;
60 offset = 0;
61 }
62 spin_unlock(lock: &fi->rdc.lock);
63
64 if (offset) {
65 page = find_lock_page(mapping: file->f_mapping, index);
66 } else {
67 page = find_or_create_page(mapping: file->f_mapping, index,
68 gfp_mask: mapping_gfp_mask(mapping: file->f_mapping));
69 }
70 if (!page)
71 return;
72
73 spin_lock(lock: &fi->rdc.lock);
74 /* Raced with another readdir */
75 if (fi->rdc.version != version || fi->rdc.size != size ||
76 WARN_ON(fi->rdc.pos != pos))
77 goto unlock;
78
79 addr = kmap_local_page(page);
80 if (!offset) {
81 clear_page(page: addr);
82 SetPageUptodate(page);
83 }
84 memcpy(addr + offset, dirent, reclen);
85 kunmap_local(addr);
86 fi->rdc.size = (index << PAGE_SHIFT) + offset + reclen;
87 fi->rdc.pos = dirent->off;
88unlock:
89 spin_unlock(lock: &fi->rdc.lock);
90 unlock_page(page);
91 put_page(page);
92}
93
94static void fuse_readdir_cache_end(struct file *file, loff_t pos)
95{
96 struct fuse_inode *fi = get_fuse_inode(inode: file_inode(f: file));
97 loff_t end;
98
99 spin_lock(lock: &fi->rdc.lock);
100 /* does cache end position match current position? */
101 if (fi->rdc.pos != pos) {
102 spin_unlock(lock: &fi->rdc.lock);
103 return;
104 }
105
106 fi->rdc.cached = true;
107 end = ALIGN(fi->rdc.size, PAGE_SIZE);
108 spin_unlock(lock: &fi->rdc.lock);
109
110 /* truncate unused tail of cache */
111 truncate_inode_pages(mapping: file->f_mapping, lstart: end);
112}
113
114static bool fuse_emit(struct file *file, struct dir_context *ctx,
115 struct fuse_dirent *dirent)
116{
117 struct fuse_file *ff = file->private_data;
118
119 if (ff->open_flags & FOPEN_CACHE_DIR)
120 fuse_add_dirent_to_cache(file, dirent, pos: ctx->pos);
121
122 return dir_emit(ctx, name: dirent->name, namelen: dirent->namelen, ino: dirent->ino,
123 type: dirent->type | FILLDIR_FLAG_NOINTR);
124}
125
126static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
127 struct dir_context *ctx)
128{
129 while (nbytes >= FUSE_NAME_OFFSET) {
130 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
131 size_t reclen = FUSE_DIRENT_SIZE(dirent);
132 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
133 return -EIO;
134 if (reclen > nbytes)
135 break;
136 if (memchr(p: dirent->name, c: '/', size: dirent->namelen) != NULL)
137 return -EIO;
138
139 if (!fuse_emit(file, ctx, dirent))
140 break;
141
142 buf += reclen;
143 nbytes -= reclen;
144 ctx->pos = dirent->off;
145 }
146
147 return 0;
148}
149
150static int fuse_direntplus_link(struct file *file,
151 struct fuse_direntplus *direntplus,
152 u64 attr_version, u64 evict_ctr)
153{
154 struct fuse_entry_out *o = &direntplus->entry_out;
155 struct fuse_dirent *dirent = &direntplus->dirent;
156 struct dentry *parent = file->f_path.dentry;
157 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
158 struct dentry *dentry;
159 struct dentry *alias;
160 struct inode *dir = d_inode(dentry: parent);
161 struct fuse_conn *fc;
162 struct inode *inode;
163 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
164 int epoch;
165
166 if (!o->nodeid) {
167 /*
168 * Unlike in the case of fuse_lookup, zero nodeid does not mean
169 * ENOENT. Instead, it only means the userspace filesystem did
170 * not want to return attributes/handle for this entry.
171 *
172 * So do nothing.
173 */
174 return 0;
175 }
176
177 if (name.name[0] == '.') {
178 /*
179 * We could potentially refresh the attributes of the directory
180 * and its parent?
181 */
182 if (name.len == 1)
183 return 0;
184 if (name.name[1] == '.' && name.len == 2)
185 return 0;
186 }
187
188 if (invalid_nodeid(nodeid: o->nodeid))
189 return -EIO;
190 if (fuse_invalid_attr(attr: &o->attr))
191 return -EIO;
192
193 fc = get_fuse_conn(inode: dir);
194 epoch = atomic_read(v: &fc->epoch);
195
196 name.hash = full_name_hash(salt: parent, name.name, name.len);
197 dentry = d_lookup(parent, &name);
198 if (!dentry) {
199retry:
200 dentry = d_alloc_parallel(parent, &name, &wq);
201 if (IS_ERR(ptr: dentry))
202 return PTR_ERR(ptr: dentry);
203 }
204 if (!d_in_lookup(dentry)) {
205 struct fuse_inode *fi;
206 inode = d_inode(dentry);
207 if (inode && get_node_id(inode) != o->nodeid)
208 inode = NULL;
209 if (!inode ||
210 fuse_stale_inode(inode, generation: o->generation, attr: &o->attr)) {
211 if (inode)
212 fuse_make_bad(inode);
213 d_invalidate(dentry);
214 dput(dentry);
215 goto retry;
216 }
217 if (fuse_is_bad(inode)) {
218 dput(dentry);
219 return -EIO;
220 }
221
222 fi = get_fuse_inode(inode);
223 spin_lock(lock: &fi->lock);
224 fi->nlookup++;
225 spin_unlock(lock: &fi->lock);
226
227 forget_all_cached_acls(inode);
228 fuse_change_attributes(inode, attr: &o->attr, NULL,
229 ATTR_TIMEOUT(o),
230 attr_version);
231 /*
232 * The other branch comes via fuse_iget()
233 * which bumps nlookup inside
234 */
235 } else {
236 inode = fuse_iget(sb: dir->i_sb, nodeid: o->nodeid, generation: o->generation,
237 attr: &o->attr, ATTR_TIMEOUT(o),
238 attr_version, evict_ctr);
239 if (!inode)
240 inode = ERR_PTR(error: -ENOMEM);
241
242 alias = d_splice_alias(inode, dentry);
243 d_lookup_done(dentry);
244 if (alias) {
245 dput(dentry);
246 dentry = alias;
247 }
248 if (IS_ERR(ptr: dentry)) {
249 if (!IS_ERR(ptr: inode)) {
250 struct fuse_inode *fi = get_fuse_inode(inode);
251
252 spin_lock(lock: &fi->lock);
253 fi->nlookup--;
254 spin_unlock(lock: &fi->lock);
255 }
256 return PTR_ERR(ptr: dentry);
257 }
258 }
259 if (fc->readdirplus_auto)
260 set_bit(nr: FUSE_I_INIT_RDPLUS, addr: &get_fuse_inode(inode)->state);
261 dentry->d_time = epoch;
262 fuse_change_entry_timeout(entry: dentry, o);
263
264 dput(dentry);
265 return 0;
266}
267
268static void fuse_force_forget(struct file *file, u64 nodeid)
269{
270 struct inode *inode = file_inode(f: file);
271 struct fuse_mount *fm = get_fuse_mount(inode);
272 struct fuse_forget_in inarg;
273 FUSE_ARGS(args);
274
275 memset(&inarg, 0, sizeof(inarg));
276 inarg.nlookup = 1;
277 args.opcode = FUSE_FORGET;
278 args.nodeid = nodeid;
279 args.in_numargs = 1;
280 args.in_args[0].size = sizeof(inarg);
281 args.in_args[0].value = &inarg;
282 args.force = true;
283 args.noreply = true;
284
285 fuse_simple_request(fm, args: &args);
286 /* ignore errors */
287}
288
289static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
290 struct dir_context *ctx, u64 attr_version,
291 u64 evict_ctr)
292{
293 struct fuse_direntplus *direntplus;
294 struct fuse_dirent *dirent;
295 size_t reclen;
296 int over = 0;
297 int ret;
298
299 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
300 direntplus = (struct fuse_direntplus *) buf;
301 dirent = &direntplus->dirent;
302 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
303
304 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
305 return -EIO;
306 if (reclen > nbytes)
307 break;
308 if (memchr(p: dirent->name, c: '/', size: dirent->namelen) != NULL)
309 return -EIO;
310
311 if (!over) {
312 /* We fill entries into dstbuf only as much as
313 it can hold. But we still continue iterating
314 over remaining entries to link them. If not,
315 we need to send a FORGET for each of those
316 which we did not link.
317 */
318 over = !fuse_emit(file, ctx, dirent);
319 if (!over)
320 ctx->pos = dirent->off;
321 }
322
323 buf += reclen;
324 nbytes -= reclen;
325
326 ret = fuse_direntplus_link(file, direntplus, attr_version, evict_ctr);
327 if (ret)
328 fuse_force_forget(file, nodeid: direntplus->entry_out.nodeid);
329 }
330
331 return 0;
332}
333
334static int fuse_readdir_uncached(struct file *file, struct dir_context *ctx)
335{
336 int plus;
337 ssize_t res;
338 struct inode *inode = file_inode(f: file);
339 struct fuse_mount *fm = get_fuse_mount(inode);
340 struct fuse_conn *fc = fm->fc;
341 struct fuse_io_args ia = {};
342 struct fuse_args *args = &ia.ap.args;
343 void *buf;
344 size_t bufsize = clamp((unsigned int) ctx->count, PAGE_SIZE, fc->max_pages << PAGE_SHIFT);
345 u64 attr_version = 0, evict_ctr = 0;
346 bool locked;
347
348 buf = kvmalloc(bufsize, GFP_KERNEL);
349 if (!buf)
350 return -ENOMEM;
351
352 args->out_args[0].value = buf;
353
354 plus = fuse_use_readdirplus(dir: inode, ctx);
355 if (plus) {
356 attr_version = fuse_get_attr_version(fc: fm->fc);
357 evict_ctr = fuse_get_evict_ctr(fc: fm->fc);
358 fuse_read_args_fill(ia: &ia, file, pos: ctx->pos, count: bufsize, opcode: FUSE_READDIRPLUS);
359 } else {
360 fuse_read_args_fill(ia: &ia, file, pos: ctx->pos, count: bufsize, opcode: FUSE_READDIR);
361 }
362 locked = fuse_lock_inode(inode);
363 res = fuse_simple_request(fm, args);
364 fuse_unlock_inode(inode, locked);
365 if (res >= 0) {
366 if (!res) {
367 struct fuse_file *ff = file->private_data;
368
369 if (ff->open_flags & FOPEN_CACHE_DIR)
370 fuse_readdir_cache_end(file, pos: ctx->pos);
371 } else if (plus) {
372 res = parse_dirplusfile(buf, nbytes: res, file, ctx, attr_version,
373 evict_ctr);
374 } else {
375 res = parse_dirfile(buf, nbytes: res, file, ctx);
376 }
377 }
378
379 kvfree(addr: buf);
380 fuse_invalidate_atime(inode);
381 return res;
382}
383
384enum fuse_parse_result {
385 FOUND_ERR = -1,
386 FOUND_NONE = 0,
387 FOUND_SOME,
388 FOUND_ALL,
389};
390
391static enum fuse_parse_result fuse_parse_cache(struct fuse_file *ff,
392 void *addr, unsigned int size,
393 struct dir_context *ctx)
394{
395 unsigned int offset = ff->readdir.cache_off & ~PAGE_MASK;
396 enum fuse_parse_result res = FOUND_NONE;
397
398 WARN_ON(offset >= size);
399
400 for (;;) {
401 struct fuse_dirent *dirent = addr + offset;
402 unsigned int nbytes = size - offset;
403 size_t reclen;
404
405 if (nbytes < FUSE_NAME_OFFSET || !dirent->namelen)
406 break;
407
408 reclen = FUSE_DIRENT_SIZE(dirent); /* derefs ->namelen */
409
410 if (WARN_ON(dirent->namelen > FUSE_NAME_MAX))
411 return FOUND_ERR;
412 if (WARN_ON(reclen > nbytes))
413 return FOUND_ERR;
414 if (WARN_ON(memchr(dirent->name, '/', dirent->namelen) != NULL))
415 return FOUND_ERR;
416
417 if (ff->readdir.pos == ctx->pos) {
418 res = FOUND_SOME;
419 if (!dir_emit(ctx, name: dirent->name, namelen: dirent->namelen,
420 ino: dirent->ino, type: dirent->type | FILLDIR_FLAG_NOINTR))
421 return FOUND_ALL;
422 ctx->pos = dirent->off;
423 }
424 ff->readdir.pos = dirent->off;
425 ff->readdir.cache_off += reclen;
426
427 offset += reclen;
428 }
429
430 return res;
431}
432
433static void fuse_rdc_reset(struct inode *inode)
434{
435 struct fuse_inode *fi = get_fuse_inode(inode);
436
437 fi->rdc.cached = false;
438 fi->rdc.version++;
439 fi->rdc.size = 0;
440 fi->rdc.pos = 0;
441}
442
443#define UNCACHED 1
444
445static int fuse_readdir_cached(struct file *file, struct dir_context *ctx)
446{
447 struct fuse_file *ff = file->private_data;
448 struct inode *inode = file_inode(f: file);
449 struct fuse_conn *fc = get_fuse_conn(inode);
450 struct fuse_inode *fi = get_fuse_inode(inode);
451 enum fuse_parse_result res;
452 pgoff_t index;
453 unsigned int size;
454 struct page *page;
455 void *addr;
456
457 /* Seeked? If so, reset the cache stream */
458 if (ff->readdir.pos != ctx->pos) {
459 ff->readdir.pos = 0;
460 ff->readdir.cache_off = 0;
461 }
462
463 /*
464 * We're just about to start reading into the cache or reading the
465 * cache; both cases require an up-to-date mtime value.
466 */
467 if (!ctx->pos && fc->auto_inval_data) {
468 int err = fuse_update_attributes(inode, file, STATX_MTIME);
469
470 if (err)
471 return err;
472 }
473
474retry:
475 spin_lock(lock: &fi->rdc.lock);
476retry_locked:
477 if (!fi->rdc.cached) {
478 /* Starting cache? Set cache mtime. */
479 if (!ctx->pos && !fi->rdc.size) {
480 fi->rdc.mtime = inode_get_mtime(inode);
481 fi->rdc.iversion = inode_query_iversion(inode);
482 }
483 spin_unlock(lock: &fi->rdc.lock);
484 return UNCACHED;
485 }
486 /*
487 * When at the beginning of the directory (i.e. just after opendir(3) or
488 * rewinddir(3)), then need to check whether directory contents have
489 * changed, and reset the cache if so.
490 */
491 if (!ctx->pos) {
492 struct timespec64 mtime = inode_get_mtime(inode);
493
494 if (inode_peek_iversion(inode) != fi->rdc.iversion ||
495 !timespec64_equal(a: &fi->rdc.mtime, b: &mtime)) {
496 fuse_rdc_reset(inode);
497 goto retry_locked;
498 }
499 }
500
501 /*
502 * If cache version changed since the last getdents() call, then reset
503 * the cache stream.
504 */
505 if (ff->readdir.version != fi->rdc.version) {
506 ff->readdir.pos = 0;
507 ff->readdir.cache_off = 0;
508 }
509 /*
510 * If at the beginning of the cache, than reset version to
511 * current.
512 */
513 if (ff->readdir.pos == 0)
514 ff->readdir.version = fi->rdc.version;
515
516 WARN_ON(fi->rdc.size < ff->readdir.cache_off);
517
518 index = ff->readdir.cache_off >> PAGE_SHIFT;
519
520 if (index == (fi->rdc.size >> PAGE_SHIFT))
521 size = fi->rdc.size & ~PAGE_MASK;
522 else
523 size = PAGE_SIZE;
524 spin_unlock(lock: &fi->rdc.lock);
525
526 /* EOF? */
527 if ((ff->readdir.cache_off & ~PAGE_MASK) == size)
528 return 0;
529
530 page = find_get_page_flags(mapping: file->f_mapping, offset: index,
531 FGP_ACCESSED | FGP_LOCK);
532 /* Page gone missing, then re-added to cache, but not initialized? */
533 if (page && !PageUptodate(page)) {
534 unlock_page(page);
535 put_page(page);
536 page = NULL;
537 }
538 spin_lock(lock: &fi->rdc.lock);
539 if (!page) {
540 /*
541 * Uh-oh: page gone missing, cache is useless
542 */
543 if (fi->rdc.version == ff->readdir.version)
544 fuse_rdc_reset(inode);
545 goto retry_locked;
546 }
547
548 /* Make sure it's still the same version after getting the page. */
549 if (ff->readdir.version != fi->rdc.version) {
550 spin_unlock(lock: &fi->rdc.lock);
551 unlock_page(page);
552 put_page(page);
553 goto retry;
554 }
555 spin_unlock(lock: &fi->rdc.lock);
556
557 /*
558 * Contents of the page are now protected against changing by holding
559 * the page lock.
560 */
561 addr = kmap_local_page(page);
562 res = fuse_parse_cache(ff, addr, size, ctx);
563 kunmap_local(addr);
564 unlock_page(page);
565 put_page(page);
566
567 if (res == FOUND_ERR)
568 return -EIO;
569
570 if (res == FOUND_ALL)
571 return 0;
572
573 if (size == PAGE_SIZE) {
574 /* We hit end of page: skip to next page. */
575 ff->readdir.cache_off = ALIGN(ff->readdir.cache_off, PAGE_SIZE);
576 goto retry;
577 }
578
579 /*
580 * End of cache reached. If found position, then we are done, otherwise
581 * need to fall back to uncached, since the position we were looking for
582 * wasn't in the cache.
583 */
584 return res == FOUND_SOME ? 0 : UNCACHED;
585}
586
587int fuse_readdir(struct file *file, struct dir_context *ctx)
588{
589 struct fuse_file *ff = file->private_data;
590 struct inode *inode = file_inode(f: file);
591 int err;
592
593 if (fuse_is_bad(inode))
594 return -EIO;
595
596 err = UNCACHED;
597 if (ff->open_flags & FOPEN_CACHE_DIR)
598 err = fuse_readdir_cached(file, ctx);
599 if (err == UNCACHED)
600 err = fuse_readdir_uncached(file, ctx);
601
602 return err;
603}
604

source code of linux/fs/fuse/readdir.c