Loading...
1/*
2 *
3 * Copyright (C) 2011 Novell Inc.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 */
9
10#include <linux/fs.h>
11#include <linux/slab.h>
12#include <linux/namei.h>
13#include <linux/file.h>
14#include <linux/xattr.h>
15#include <linux/rbtree.h>
16#include <linux/security.h>
17#include <linux/cred.h>
18#include "overlayfs.h"
19
20struct ovl_cache_entry {
21 unsigned int len;
22 unsigned int type;
23 u64 ino;
24 struct list_head l_node;
25 struct rb_node node;
26 struct ovl_cache_entry *next_maybe_whiteout;
27 bool is_whiteout;
28 char name[];
29};
30
31struct ovl_dir_cache {
32 long refcount;
33 u64 version;
34 struct list_head entries;
35};
36
37struct ovl_readdir_data {
38 struct dir_context ctx;
39 bool is_lowest;
40 struct rb_root root;
41 struct list_head *list;
42 struct list_head middle;
43 struct ovl_cache_entry *first_maybe_whiteout;
44 int count;
45 int err;
46 bool d_type_supported;
47};
48
49struct ovl_dir_file {
50 bool is_real;
51 bool is_upper;
52 struct ovl_dir_cache *cache;
53 struct list_head *cursor;
54 struct file *realfile;
55 struct file *upperfile;
56};
57
58static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n)
59{
60 return container_of(n, struct ovl_cache_entry, node);
61}
62
63static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root,
64 const char *name, int len)
65{
66 struct rb_node *node = root->rb_node;
67 int cmp;
68
69 while (node) {
70 struct ovl_cache_entry *p = ovl_cache_entry_from_node(node);
71
72 cmp = strncmp(name, p->name, len);
73 if (cmp > 0)
74 node = p->node.rb_right;
75 else if (cmp < 0 || len < p->len)
76 node = p->node.rb_left;
77 else
78 return p;
79 }
80
81 return NULL;
82}
83
84static struct ovl_cache_entry *ovl_cache_entry_new(struct ovl_readdir_data *rdd,
85 const char *name, int len,
86 u64 ino, unsigned int d_type)
87{
88 struct ovl_cache_entry *p;
89 size_t size = offsetof(struct ovl_cache_entry, name[len + 1]);
90
91 p = kmalloc(size, GFP_KERNEL);
92 if (!p)
93 return NULL;
94
95 memcpy(p->name, name, len);
96 p->name[len] = '\0';
97 p->len = len;
98 p->type = d_type;
99 p->ino = ino;
100 p->is_whiteout = false;
101
102 if (d_type == DT_CHR) {
103 p->next_maybe_whiteout = rdd->first_maybe_whiteout;
104 rdd->first_maybe_whiteout = p;
105 }
106 return p;
107}
108
109static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd,
110 const char *name, int len, u64 ino,
111 unsigned int d_type)
112{
113 struct rb_node **newp = &rdd->root.rb_node;
114 struct rb_node *parent = NULL;
115 struct ovl_cache_entry *p;
116
117 while (*newp) {
118 int cmp;
119 struct ovl_cache_entry *tmp;
120
121 parent = *newp;
122 tmp = ovl_cache_entry_from_node(*newp);
123 cmp = strncmp(name, tmp->name, len);
124 if (cmp > 0)
125 newp = &tmp->node.rb_right;
126 else if (cmp < 0 || len < tmp->len)
127 newp = &tmp->node.rb_left;
128 else
129 return 0;
130 }
131
132 p = ovl_cache_entry_new(rdd, name, len, ino, d_type);
133 if (p == NULL)
134 return -ENOMEM;
135
136 list_add_tail(&p->l_node, rdd->list);
137 rb_link_node(&p->node, parent, newp);
138 rb_insert_color(&p->node, &rdd->root);
139
140 return 0;
141}
142
143static int ovl_fill_lowest(struct ovl_readdir_data *rdd,
144 const char *name, int namelen,
145 loff_t offset, u64 ino, unsigned int d_type)
146{
147 struct ovl_cache_entry *p;
148
149 p = ovl_cache_entry_find(&rdd->root, name, namelen);
150 if (p) {
151 list_move_tail(&p->l_node, &rdd->middle);
152 } else {
153 p = ovl_cache_entry_new(rdd, name, namelen, ino, d_type);
154 if (p == NULL)
155 rdd->err = -ENOMEM;
156 else
157 list_add_tail(&p->l_node, &rdd->middle);
158 }
159
160 return rdd->err;
161}
162
163void ovl_cache_free(struct list_head *list)
164{
165 struct ovl_cache_entry *p;
166 struct ovl_cache_entry *n;
167
168 list_for_each_entry_safe(p, n, list, l_node)
169 kfree(p);
170
171 INIT_LIST_HEAD(list);
172}
173
174static void ovl_cache_put(struct ovl_dir_file *od, struct dentry *dentry)
175{
176 struct ovl_dir_cache *cache = od->cache;
177
178 WARN_ON(cache->refcount <= 0);
179 cache->refcount--;
180 if (!cache->refcount) {
181 if (ovl_dir_cache(dentry) == cache)
182 ovl_set_dir_cache(dentry, NULL);
183
184 ovl_cache_free(&cache->entries);
185 kfree(cache);
186 }
187}
188
189static int ovl_fill_merge(struct dir_context *ctx, const char *name,
190 int namelen, loff_t offset, u64 ino,
191 unsigned int d_type)
192{
193 struct ovl_readdir_data *rdd =
194 container_of(ctx, struct ovl_readdir_data, ctx);
195
196 rdd->count++;
197 if (!rdd->is_lowest)
198 return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type);
199 else
200 return ovl_fill_lowest(rdd, name, namelen, offset, ino, d_type);
201}
202
203static int ovl_check_whiteouts(struct dentry *dir, struct ovl_readdir_data *rdd)
204{
205 int err;
206 struct ovl_cache_entry *p;
207 struct dentry *dentry;
208 const struct cred *old_cred;
209 struct cred *override_cred;
210
211 override_cred = prepare_creds();
212 if (!override_cred)
213 return -ENOMEM;
214
215 /*
216 * CAP_DAC_OVERRIDE for lookup
217 */
218 cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
219 old_cred = override_creds(override_cred);
220
221 err = mutex_lock_killable(&dir->d_inode->i_mutex);
222 if (!err) {
223 while (rdd->first_maybe_whiteout) {
224 p = rdd->first_maybe_whiteout;
225 rdd->first_maybe_whiteout = p->next_maybe_whiteout;
226 dentry = lookup_one_len(p->name, dir, p->len);
227 if (!IS_ERR(dentry)) {
228 p->is_whiteout = ovl_is_whiteout(dentry);
229 dput(dentry);
230 }
231 }
232 inode_unlock(dir->d_inode);
233 }
234 revert_creds(old_cred);
235 put_cred(override_cred);
236
237 return err;
238}
239
240static inline int ovl_dir_read(struct path *realpath,
241 struct ovl_readdir_data *rdd)
242{
243 struct file *realfile;
244 int err;
245
246 realfile = ovl_path_open(realpath, O_RDONLY | O_DIRECTORY);
247 if (IS_ERR(realfile))
248 return PTR_ERR(realfile);
249
250 rdd->first_maybe_whiteout = NULL;
251 rdd->ctx.pos = 0;
252 do {
253 rdd->count = 0;
254 rdd->err = 0;
255 err = iterate_dir(realfile, &rdd->ctx);
256 if (err >= 0)
257 err = rdd->err;
258 } while (!err && rdd->count);
259
260 if (!err && rdd->first_maybe_whiteout)
261 err = ovl_check_whiteouts(realpath->dentry, rdd);
262
263 fput(realfile);
264
265 return err;
266}
267
268static void ovl_dir_reset(struct file *file)
269{
270 struct ovl_dir_file *od = file->private_data;
271 struct ovl_dir_cache *cache = od->cache;
272 struct dentry *dentry = file->f_path.dentry;
273 enum ovl_path_type type = ovl_path_type(dentry);
274
275 if (cache && ovl_dentry_version_get(dentry) != cache->version) {
276 ovl_cache_put(od, dentry);
277 od->cache = NULL;
278 od->cursor = NULL;
279 }
280 WARN_ON(!od->is_real && !OVL_TYPE_MERGE(type));
281 if (od->is_real && OVL_TYPE_MERGE(type))
282 od->is_real = false;
283}
284
285static int ovl_dir_read_merged(struct dentry *dentry, struct list_head *list)
286{
287 int err;
288 struct path realpath;
289 struct ovl_readdir_data rdd = {
290 .ctx.actor = ovl_fill_merge,
291 .list = list,
292 .root = RB_ROOT,
293 .is_lowest = false,
294 };
295 int idx, next;
296
297 for (idx = 0; idx != -1; idx = next) {
298 next = ovl_path_next(idx, dentry, &realpath);
299
300 if (next != -1) {
301 err = ovl_dir_read(&realpath, &rdd);
302 if (err)
303 break;
304 } else {
305 /*
306 * Insert lowest layer entries before upper ones, this
307 * allows offsets to be reasonably constant
308 */
309 list_add(&rdd.middle, rdd.list);
310 rdd.is_lowest = true;
311 err = ovl_dir_read(&realpath, &rdd);
312 list_del(&rdd.middle);
313 }
314 }
315 return err;
316}
317
318static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
319{
320 struct list_head *p;
321 loff_t off = 0;
322
323 list_for_each(p, &od->cache->entries) {
324 if (off >= pos)
325 break;
326 off++;
327 }
328 /* Cursor is safe since the cache is stable */
329 od->cursor = p;
330}
331
332static struct ovl_dir_cache *ovl_cache_get(struct dentry *dentry)
333{
334 int res;
335 struct ovl_dir_cache *cache;
336
337 cache = ovl_dir_cache(dentry);
338 if (cache && ovl_dentry_version_get(dentry) == cache->version) {
339 cache->refcount++;
340 return cache;
341 }
342 ovl_set_dir_cache(dentry, NULL);
343
344 cache = kzalloc(sizeof(struct ovl_dir_cache), GFP_KERNEL);
345 if (!cache)
346 return ERR_PTR(-ENOMEM);
347
348 cache->refcount = 1;
349 INIT_LIST_HEAD(&cache->entries);
350
351 res = ovl_dir_read_merged(dentry, &cache->entries);
352 if (res) {
353 ovl_cache_free(&cache->entries);
354 kfree(cache);
355 return ERR_PTR(res);
356 }
357
358 cache->version = ovl_dentry_version_get(dentry);
359 ovl_set_dir_cache(dentry, cache);
360
361 return cache;
362}
363
364static int ovl_iterate(struct file *file, struct dir_context *ctx)
365{
366 struct ovl_dir_file *od = file->private_data;
367 struct dentry *dentry = file->f_path.dentry;
368 struct ovl_cache_entry *p;
369
370 if (!ctx->pos)
371 ovl_dir_reset(file);
372
373 if (od->is_real)
374 return iterate_dir(od->realfile, ctx);
375
376 if (!od->cache) {
377 struct ovl_dir_cache *cache;
378
379 cache = ovl_cache_get(dentry);
380 if (IS_ERR(cache))
381 return PTR_ERR(cache);
382
383 od->cache = cache;
384 ovl_seek_cursor(od, ctx->pos);
385 }
386
387 while (od->cursor != &od->cache->entries) {
388 p = list_entry(od->cursor, struct ovl_cache_entry, l_node);
389 if (!p->is_whiteout)
390 if (!dir_emit(ctx, p->name, p->len, p->ino, p->type))
391 break;
392 od->cursor = p->l_node.next;
393 ctx->pos++;
394 }
395 return 0;
396}
397
398static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin)
399{
400 loff_t res;
401 struct ovl_dir_file *od = file->private_data;
402
403 inode_lock(file_inode(file));
404 if (!file->f_pos)
405 ovl_dir_reset(file);
406
407 if (od->is_real) {
408 res = vfs_llseek(od->realfile, offset, origin);
409 file->f_pos = od->realfile->f_pos;
410 } else {
411 res = -EINVAL;
412
413 switch (origin) {
414 case SEEK_CUR:
415 offset += file->f_pos;
416 break;
417 case SEEK_SET:
418 break;
419 default:
420 goto out_unlock;
421 }
422 if (offset < 0)
423 goto out_unlock;
424
425 if (offset != file->f_pos) {
426 file->f_pos = offset;
427 if (od->cache)
428 ovl_seek_cursor(od, offset);
429 }
430 res = offset;
431 }
432out_unlock:
433 inode_unlock(file_inode(file));
434
435 return res;
436}
437
438static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end,
439 int datasync)
440{
441 struct ovl_dir_file *od = file->private_data;
442 struct dentry *dentry = file->f_path.dentry;
443 struct file *realfile = od->realfile;
444
445 /*
446 * Need to check if we started out being a lower dir, but got copied up
447 */
448 if (!od->is_upper && OVL_TYPE_UPPER(ovl_path_type(dentry))) {
449 struct inode *inode = file_inode(file);
450
451 realfile = lockless_dereference(od->upperfile);
452 if (!realfile) {
453 struct path upperpath;
454
455 ovl_path_upper(dentry, &upperpath);
456 realfile = ovl_path_open(&upperpath, O_RDONLY);
457 smp_mb__before_spinlock();
458 inode_lock(inode);
459 if (!od->upperfile) {
460 if (IS_ERR(realfile)) {
461 inode_unlock(inode);
462 return PTR_ERR(realfile);
463 }
464 od->upperfile = realfile;
465 } else {
466 /* somebody has beaten us to it */
467 if (!IS_ERR(realfile))
468 fput(realfile);
469 realfile = od->upperfile;
470 }
471 inode_unlock(inode);
472 }
473 }
474
475 return vfs_fsync_range(realfile, start, end, datasync);
476}
477
478static int ovl_dir_release(struct inode *inode, struct file *file)
479{
480 struct ovl_dir_file *od = file->private_data;
481
482 if (od->cache) {
483 inode_lock(inode);
484 ovl_cache_put(od, file->f_path.dentry);
485 inode_unlock(inode);
486 }
487 fput(od->realfile);
488 if (od->upperfile)
489 fput(od->upperfile);
490 kfree(od);
491
492 return 0;
493}
494
495static int ovl_dir_open(struct inode *inode, struct file *file)
496{
497 struct path realpath;
498 struct file *realfile;
499 struct ovl_dir_file *od;
500 enum ovl_path_type type;
501
502 od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL);
503 if (!od)
504 return -ENOMEM;
505
506 type = ovl_path_real(file->f_path.dentry, &realpath);
507 realfile = ovl_path_open(&realpath, file->f_flags);
508 if (IS_ERR(realfile)) {
509 kfree(od);
510 return PTR_ERR(realfile);
511 }
512 od->realfile = realfile;
513 od->is_real = !OVL_TYPE_MERGE(type);
514 od->is_upper = OVL_TYPE_UPPER(type);
515 file->private_data = od;
516
517 return 0;
518}
519
520const struct file_operations ovl_dir_operations = {
521 .read = generic_read_dir,
522 .open = ovl_dir_open,
523 .iterate = ovl_iterate,
524 .llseek = ovl_dir_llseek,
525 .fsync = ovl_dir_fsync,
526 .release = ovl_dir_release,
527};
528
529int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list)
530{
531 int err;
532 struct ovl_cache_entry *p;
533
534 err = ovl_dir_read_merged(dentry, list);
535 if (err)
536 return err;
537
538 err = 0;
539
540 list_for_each_entry(p, list, l_node) {
541 if (p->is_whiteout)
542 continue;
543
544 if (p->name[0] == '.') {
545 if (p->len == 1)
546 continue;
547 if (p->len == 2 && p->name[1] == '.')
548 continue;
549 }
550 err = -ENOTEMPTY;
551 break;
552 }
553
554 return err;
555}
556
557void ovl_cleanup_whiteouts(struct dentry *upper, struct list_head *list)
558{
559 struct ovl_cache_entry *p;
560
561 inode_lock_nested(upper->d_inode, I_MUTEX_CHILD);
562 list_for_each_entry(p, list, l_node) {
563 struct dentry *dentry;
564
565 if (!p->is_whiteout)
566 continue;
567
568 dentry = lookup_one_len(p->name, upper, p->len);
569 if (IS_ERR(dentry)) {
570 pr_err("overlayfs: lookup '%s/%.*s' failed (%i)\n",
571 upper->d_name.name, p->len, p->name,
572 (int) PTR_ERR(dentry));
573 continue;
574 }
575 if (dentry->d_inode)
576 ovl_cleanup(upper->d_inode, dentry);
577 dput(dentry);
578 }
579 inode_unlock(upper->d_inode);
580}
581
582static int ovl_check_d_type(struct dir_context *ctx, const char *name,
583 int namelen, loff_t offset, u64 ino,
584 unsigned int d_type)
585{
586 struct ovl_readdir_data *rdd =
587 container_of(ctx, struct ovl_readdir_data, ctx);
588
589 /* Even if d_type is not supported, DT_DIR is returned for . and .. */
590 if (!strncmp(name, ".", namelen) || !strncmp(name, "..", namelen))
591 return 0;
592
593 if (d_type != DT_UNKNOWN)
594 rdd->d_type_supported = true;
595
596 return 0;
597}
598
599/*
600 * Returns 1 if d_type is supported, 0 not supported/unknown. Negative values
601 * if error is encountered.
602 */
603int ovl_check_d_type_supported(struct path *realpath)
604{
605 int err;
606 struct ovl_readdir_data rdd = {
607 .ctx.actor = ovl_check_d_type,
608 .d_type_supported = false,
609 };
610
611 err = ovl_dir_read(realpath, &rdd);
612 if (err)
613 return err;
614
615 return rdd.d_type_supported;
616}
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 *
4 * Copyright (C) 2011 Novell Inc.
5 */
6
7#include <linux/fs.h>
8#include <linux/slab.h>
9#include <linux/namei.h>
10#include <linux/file.h>
11#include <linux/xattr.h>
12#include <linux/rbtree.h>
13#include <linux/security.h>
14#include <linux/cred.h>
15#include <linux/ratelimit.h>
16#include "overlayfs.h"
17
18struct ovl_cache_entry {
19 unsigned int len;
20 unsigned int type;
21 u64 real_ino;
22 u64 ino;
23 struct list_head l_node;
24 struct rb_node node;
25 struct ovl_cache_entry *next_maybe_whiteout;
26 bool is_upper;
27 bool is_whiteout;
28 bool check_xwhiteout;
29 char name[];
30};
31
32struct ovl_dir_cache {
33 long refcount;
34 u64 version;
35 struct list_head entries;
36 struct rb_root root;
37};
38
39struct ovl_readdir_data {
40 struct dir_context ctx;
41 struct dentry *dentry;
42 bool is_lowest;
43 struct rb_root *root;
44 struct list_head *list;
45 struct list_head middle;
46 struct ovl_cache_entry *first_maybe_whiteout;
47 int count;
48 int err;
49 bool is_upper;
50 bool d_type_supported;
51 bool in_xwhiteouts_dir;
52};
53
54struct ovl_dir_file {
55 bool is_real;
56 bool is_upper;
57 struct ovl_dir_cache *cache;
58 struct list_head *cursor;
59 struct file *realfile;
60 struct file *upperfile;
61};
62
63static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n)
64{
65 return rb_entry(n, struct ovl_cache_entry, node);
66}
67
68static bool ovl_cache_entry_find_link(const char *name, int len,
69 struct rb_node ***link,
70 struct rb_node **parent)
71{
72 bool found = false;
73 struct rb_node **newp = *link;
74
75 while (!found && *newp) {
76 int cmp;
77 struct ovl_cache_entry *tmp;
78
79 *parent = *newp;
80 tmp = ovl_cache_entry_from_node(*newp);
81 cmp = strncmp(name, tmp->name, len);
82 if (cmp > 0)
83 newp = &tmp->node.rb_right;
84 else if (cmp < 0 || len < tmp->len)
85 newp = &tmp->node.rb_left;
86 else
87 found = true;
88 }
89 *link = newp;
90
91 return found;
92}
93
94static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root,
95 const char *name, int len)
96{
97 struct rb_node *node = root->rb_node;
98 int cmp;
99
100 while (node) {
101 struct ovl_cache_entry *p = ovl_cache_entry_from_node(node);
102
103 cmp = strncmp(name, p->name, len);
104 if (cmp > 0)
105 node = p->node.rb_right;
106 else if (cmp < 0 || len < p->len)
107 node = p->node.rb_left;
108 else
109 return p;
110 }
111
112 return NULL;
113}
114
115static bool ovl_calc_d_ino(struct ovl_readdir_data *rdd,
116 struct ovl_cache_entry *p)
117{
118 /* Don't care if not doing ovl_iter() */
119 if (!rdd->dentry)
120 return false;
121
122 /* Always recalc d_ino when remapping lower inode numbers */
123 if (ovl_xino_bits(OVL_FS(rdd->dentry->d_sb)))
124 return true;
125
126 /* Always recalc d_ino for parent */
127 if (strcmp(p->name, "..") == 0)
128 return true;
129
130 /* If this is lower, then native d_ino will do */
131 if (!rdd->is_upper)
132 return false;
133
134 /*
135 * Recalc d_ino for '.' and for all entries if dir is impure (contains
136 * copied up entries)
137 */
138 if ((p->name[0] == '.' && p->len == 1) ||
139 ovl_test_flag(OVL_IMPURE, d_inode(rdd->dentry)))
140 return true;
141
142 return false;
143}
144
145static struct ovl_cache_entry *ovl_cache_entry_new(struct ovl_readdir_data *rdd,
146 const char *name, int len,
147 u64 ino, unsigned int d_type)
148{
149 struct ovl_cache_entry *p;
150 size_t size = offsetof(struct ovl_cache_entry, name[len + 1]);
151
152 p = kmalloc(size, GFP_KERNEL);
153 if (!p)
154 return NULL;
155
156 memcpy(p->name, name, len);
157 p->name[len] = '\0';
158 p->len = len;
159 p->type = d_type;
160 p->real_ino = ino;
161 p->ino = ino;
162 /* Defer setting d_ino for upper entry to ovl_iterate() */
163 if (ovl_calc_d_ino(rdd, p))
164 p->ino = 0;
165 p->is_upper = rdd->is_upper;
166 p->is_whiteout = false;
167 /* Defer check for overlay.whiteout to ovl_iterate() */
168 p->check_xwhiteout = rdd->in_xwhiteouts_dir && d_type == DT_REG;
169
170 if (d_type == DT_CHR) {
171 p->next_maybe_whiteout = rdd->first_maybe_whiteout;
172 rdd->first_maybe_whiteout = p;
173 }
174 return p;
175}
176
177static bool ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd,
178 const char *name, int len, u64 ino,
179 unsigned int d_type)
180{
181 struct rb_node **newp = &rdd->root->rb_node;
182 struct rb_node *parent = NULL;
183 struct ovl_cache_entry *p;
184
185 if (ovl_cache_entry_find_link(name, len, &newp, &parent))
186 return true;
187
188 p = ovl_cache_entry_new(rdd, name, len, ino, d_type);
189 if (p == NULL) {
190 rdd->err = -ENOMEM;
191 return false;
192 }
193
194 list_add_tail(&p->l_node, rdd->list);
195 rb_link_node(&p->node, parent, newp);
196 rb_insert_color(&p->node, rdd->root);
197
198 return true;
199}
200
201static bool ovl_fill_lowest(struct ovl_readdir_data *rdd,
202 const char *name, int namelen,
203 loff_t offset, u64 ino, unsigned int d_type)
204{
205 struct ovl_cache_entry *p;
206
207 p = ovl_cache_entry_find(rdd->root, name, namelen);
208 if (p) {
209 list_move_tail(&p->l_node, &rdd->middle);
210 } else {
211 p = ovl_cache_entry_new(rdd, name, namelen, ino, d_type);
212 if (p == NULL)
213 rdd->err = -ENOMEM;
214 else
215 list_add_tail(&p->l_node, &rdd->middle);
216 }
217
218 return rdd->err == 0;
219}
220
221void ovl_cache_free(struct list_head *list)
222{
223 struct ovl_cache_entry *p;
224 struct ovl_cache_entry *n;
225
226 list_for_each_entry_safe(p, n, list, l_node)
227 kfree(p);
228
229 INIT_LIST_HEAD(list);
230}
231
232void ovl_dir_cache_free(struct inode *inode)
233{
234 struct ovl_dir_cache *cache = ovl_dir_cache(inode);
235
236 if (cache) {
237 ovl_cache_free(&cache->entries);
238 kfree(cache);
239 }
240}
241
242static void ovl_cache_put(struct ovl_dir_file *od, struct inode *inode)
243{
244 struct ovl_dir_cache *cache = od->cache;
245
246 WARN_ON(cache->refcount <= 0);
247 cache->refcount--;
248 if (!cache->refcount) {
249 if (ovl_dir_cache(inode) == cache)
250 ovl_set_dir_cache(inode, NULL);
251
252 ovl_cache_free(&cache->entries);
253 kfree(cache);
254 }
255}
256
257static bool ovl_fill_merge(struct dir_context *ctx, const char *name,
258 int namelen, loff_t offset, u64 ino,
259 unsigned int d_type)
260{
261 struct ovl_readdir_data *rdd =
262 container_of(ctx, struct ovl_readdir_data, ctx);
263
264 rdd->count++;
265 if (!rdd->is_lowest)
266 return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type);
267 else
268 return ovl_fill_lowest(rdd, name, namelen, offset, ino, d_type);
269}
270
271static int ovl_check_whiteouts(const struct path *path, struct ovl_readdir_data *rdd)
272{
273 int err;
274 struct ovl_cache_entry *p;
275 struct dentry *dentry, *dir = path->dentry;
276 const struct cred *old_cred;
277
278 old_cred = ovl_override_creds(rdd->dentry->d_sb);
279
280 err = down_write_killable(&dir->d_inode->i_rwsem);
281 if (!err) {
282 while (rdd->first_maybe_whiteout) {
283 p = rdd->first_maybe_whiteout;
284 rdd->first_maybe_whiteout = p->next_maybe_whiteout;
285 dentry = lookup_one(mnt_idmap(path->mnt), p->name, dir, p->len);
286 if (!IS_ERR(dentry)) {
287 p->is_whiteout = ovl_is_whiteout(dentry);
288 dput(dentry);
289 }
290 }
291 inode_unlock(dir->d_inode);
292 }
293 revert_creds(old_cred);
294
295 return err;
296}
297
298static inline int ovl_dir_read(const struct path *realpath,
299 struct ovl_readdir_data *rdd)
300{
301 struct file *realfile;
302 int err;
303
304 realfile = ovl_path_open(realpath, O_RDONLY | O_LARGEFILE);
305 if (IS_ERR(realfile))
306 return PTR_ERR(realfile);
307
308 rdd->first_maybe_whiteout = NULL;
309 rdd->ctx.pos = 0;
310 do {
311 rdd->count = 0;
312 rdd->err = 0;
313 err = iterate_dir(realfile, &rdd->ctx);
314 if (err >= 0)
315 err = rdd->err;
316 } while (!err && rdd->count);
317
318 if (!err && rdd->first_maybe_whiteout && rdd->dentry)
319 err = ovl_check_whiteouts(realpath, rdd);
320
321 fput(realfile);
322
323 return err;
324}
325
326static void ovl_dir_reset(struct file *file)
327{
328 struct ovl_dir_file *od = file->private_data;
329 struct ovl_dir_cache *cache = od->cache;
330 struct inode *inode = file_inode(file);
331 bool is_real;
332
333 if (cache && ovl_inode_version_get(inode) != cache->version) {
334 ovl_cache_put(od, inode);
335 od->cache = NULL;
336 od->cursor = NULL;
337 }
338 is_real = ovl_dir_is_real(inode);
339 if (od->is_real != is_real) {
340 /* is_real can only become false when dir is copied up */
341 if (WARN_ON(is_real))
342 return;
343 od->is_real = false;
344 }
345}
346
347static int ovl_dir_read_merged(struct dentry *dentry, struct list_head *list,
348 struct rb_root *root)
349{
350 int err;
351 struct path realpath;
352 struct ovl_readdir_data rdd = {
353 .ctx.actor = ovl_fill_merge,
354 .dentry = dentry,
355 .list = list,
356 .root = root,
357 .is_lowest = false,
358 };
359 int idx, next;
360 const struct ovl_layer *layer;
361
362 for (idx = 0; idx != -1; idx = next) {
363 next = ovl_path_next(idx, dentry, &realpath, &layer);
364 rdd.is_upper = ovl_dentry_upper(dentry) == realpath.dentry;
365 rdd.in_xwhiteouts_dir = layer->has_xwhiteouts &&
366 ovl_dentry_has_xwhiteouts(dentry);
367
368 if (next != -1) {
369 err = ovl_dir_read(&realpath, &rdd);
370 if (err)
371 break;
372 } else {
373 /*
374 * Insert lowest layer entries before upper ones, this
375 * allows offsets to be reasonably constant
376 */
377 list_add(&rdd.middle, rdd.list);
378 rdd.is_lowest = true;
379 err = ovl_dir_read(&realpath, &rdd);
380 list_del(&rdd.middle);
381 }
382 }
383 return err;
384}
385
386static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
387{
388 struct list_head *p;
389 loff_t off = 0;
390
391 list_for_each(p, &od->cache->entries) {
392 if (off >= pos)
393 break;
394 off++;
395 }
396 /* Cursor is safe since the cache is stable */
397 od->cursor = p;
398}
399
400static struct ovl_dir_cache *ovl_cache_get(struct dentry *dentry)
401{
402 int res;
403 struct ovl_dir_cache *cache;
404 struct inode *inode = d_inode(dentry);
405
406 cache = ovl_dir_cache(inode);
407 if (cache && ovl_inode_version_get(inode) == cache->version) {
408 WARN_ON(!cache->refcount);
409 cache->refcount++;
410 return cache;
411 }
412 ovl_set_dir_cache(d_inode(dentry), NULL);
413
414 cache = kzalloc(sizeof(struct ovl_dir_cache), GFP_KERNEL);
415 if (!cache)
416 return ERR_PTR(-ENOMEM);
417
418 cache->refcount = 1;
419 INIT_LIST_HEAD(&cache->entries);
420 cache->root = RB_ROOT;
421
422 res = ovl_dir_read_merged(dentry, &cache->entries, &cache->root);
423 if (res) {
424 ovl_cache_free(&cache->entries);
425 kfree(cache);
426 return ERR_PTR(res);
427 }
428
429 cache->version = ovl_inode_version_get(inode);
430 ovl_set_dir_cache(inode, cache);
431
432 return cache;
433}
434
435/* Map inode number to lower fs unique range */
436static u64 ovl_remap_lower_ino(u64 ino, int xinobits, int fsid,
437 const char *name, int namelen, bool warn)
438{
439 unsigned int xinoshift = 64 - xinobits;
440
441 if (unlikely(ino >> xinoshift)) {
442 if (warn) {
443 pr_warn_ratelimited("d_ino too big (%.*s, ino=%llu, xinobits=%d)\n",
444 namelen, name, ino, xinobits);
445 }
446 return ino;
447 }
448
449 /*
450 * The lowest xinobit is reserved for mapping the non-peresistent inode
451 * numbers range, but this range is only exposed via st_ino, not here.
452 */
453 return ino | ((u64)fsid) << (xinoshift + 1);
454}
455
456/*
457 * Set d_ino for upper entries if needed. Non-upper entries should always report
458 * the uppermost real inode ino and should not call this function.
459 *
460 * When not all layer are on same fs, report real ino also for upper.
461 *
462 * When all layers are on the same fs, and upper has a reference to
463 * copy up origin, call vfs_getattr() on the overlay entry to make
464 * sure that d_ino will be consistent with st_ino from stat(2).
465 *
466 * Also checks the overlay.whiteout xattr by doing a full lookup which will return
467 * negative in this case.
468 */
469static int ovl_cache_update(const struct path *path, struct ovl_cache_entry *p, bool update_ino)
470
471{
472 struct dentry *dir = path->dentry;
473 struct ovl_fs *ofs = OVL_FS(dir->d_sb);
474 struct dentry *this = NULL;
475 enum ovl_path_type type;
476 u64 ino = p->real_ino;
477 int xinobits = ovl_xino_bits(ofs);
478 int err = 0;
479
480 if (!ovl_same_dev(ofs) && !p->check_xwhiteout)
481 goto out;
482
483 if (p->name[0] == '.') {
484 if (p->len == 1) {
485 this = dget(dir);
486 goto get;
487 }
488 if (p->len == 2 && p->name[1] == '.') {
489 /* we shall not be moved */
490 this = dget(dir->d_parent);
491 goto get;
492 }
493 }
494 /* This checks also for xwhiteouts */
495 this = lookup_one(mnt_idmap(path->mnt), p->name, dir, p->len);
496 if (IS_ERR_OR_NULL(this) || !this->d_inode) {
497 /* Mark a stale entry */
498 p->is_whiteout = true;
499 if (IS_ERR(this)) {
500 err = PTR_ERR(this);
501 this = NULL;
502 goto fail;
503 }
504 goto out;
505 }
506
507get:
508 if (!ovl_same_dev(ofs) || !update_ino)
509 goto out;
510
511 type = ovl_path_type(this);
512 if (OVL_TYPE_ORIGIN(type)) {
513 struct kstat stat;
514 struct path statpath = *path;
515
516 statpath.dentry = this;
517 err = vfs_getattr(&statpath, &stat, STATX_INO, 0);
518 if (err)
519 goto fail;
520
521 /*
522 * Directory inode is always on overlay st_dev.
523 * Non-dir with ovl_same_dev() could be on pseudo st_dev in case
524 * of xino bits overflow.
525 */
526 WARN_ON_ONCE(S_ISDIR(stat.mode) &&
527 dir->d_sb->s_dev != stat.dev);
528 ino = stat.ino;
529 } else if (xinobits && !OVL_TYPE_UPPER(type)) {
530 ino = ovl_remap_lower_ino(ino, xinobits,
531 ovl_layer_lower(this)->fsid,
532 p->name, p->len,
533 ovl_xino_warn(ofs));
534 }
535
536out:
537 p->ino = ino;
538 dput(this);
539 return err;
540
541fail:
542 pr_warn_ratelimited("failed to look up (%s) for ino (%i)\n",
543 p->name, err);
544 goto out;
545}
546
547static bool ovl_fill_plain(struct dir_context *ctx, const char *name,
548 int namelen, loff_t offset, u64 ino,
549 unsigned int d_type)
550{
551 struct ovl_cache_entry *p;
552 struct ovl_readdir_data *rdd =
553 container_of(ctx, struct ovl_readdir_data, ctx);
554
555 rdd->count++;
556 p = ovl_cache_entry_new(rdd, name, namelen, ino, d_type);
557 if (p == NULL) {
558 rdd->err = -ENOMEM;
559 return false;
560 }
561 list_add_tail(&p->l_node, rdd->list);
562
563 return true;
564}
565
566static int ovl_dir_read_impure(const struct path *path, struct list_head *list,
567 struct rb_root *root)
568{
569 int err;
570 struct path realpath;
571 struct ovl_cache_entry *p, *n;
572 struct ovl_readdir_data rdd = {
573 .ctx.actor = ovl_fill_plain,
574 .list = list,
575 .root = root,
576 };
577
578 INIT_LIST_HEAD(list);
579 *root = RB_ROOT;
580 ovl_path_upper(path->dentry, &realpath);
581
582 err = ovl_dir_read(&realpath, &rdd);
583 if (err)
584 return err;
585
586 list_for_each_entry_safe(p, n, list, l_node) {
587 if (strcmp(p->name, ".") != 0 &&
588 strcmp(p->name, "..") != 0) {
589 err = ovl_cache_update(path, p, true);
590 if (err)
591 return err;
592 }
593 if (p->ino == p->real_ino) {
594 list_del(&p->l_node);
595 kfree(p);
596 } else {
597 struct rb_node **newp = &root->rb_node;
598 struct rb_node *parent = NULL;
599
600 if (WARN_ON(ovl_cache_entry_find_link(p->name, p->len,
601 &newp, &parent)))
602 return -EIO;
603
604 rb_link_node(&p->node, parent, newp);
605 rb_insert_color(&p->node, root);
606 }
607 }
608 return 0;
609}
610
611static struct ovl_dir_cache *ovl_cache_get_impure(const struct path *path)
612{
613 int res;
614 struct dentry *dentry = path->dentry;
615 struct inode *inode = d_inode(dentry);
616 struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
617 struct ovl_dir_cache *cache;
618
619 cache = ovl_dir_cache(inode);
620 if (cache && ovl_inode_version_get(inode) == cache->version)
621 return cache;
622
623 /* Impure cache is not refcounted, free it here */
624 ovl_dir_cache_free(inode);
625 ovl_set_dir_cache(inode, NULL);
626
627 cache = kzalloc(sizeof(struct ovl_dir_cache), GFP_KERNEL);
628 if (!cache)
629 return ERR_PTR(-ENOMEM);
630
631 res = ovl_dir_read_impure(path, &cache->entries, &cache->root);
632 if (res) {
633 ovl_cache_free(&cache->entries);
634 kfree(cache);
635 return ERR_PTR(res);
636 }
637 if (list_empty(&cache->entries)) {
638 /*
639 * A good opportunity to get rid of an unneeded "impure" flag.
640 * Removing the "impure" xattr is best effort.
641 */
642 if (!ovl_want_write(dentry)) {
643 ovl_removexattr(ofs, ovl_dentry_upper(dentry),
644 OVL_XATTR_IMPURE);
645 ovl_drop_write(dentry);
646 }
647 ovl_clear_flag(OVL_IMPURE, inode);
648 kfree(cache);
649 return NULL;
650 }
651
652 cache->version = ovl_inode_version_get(inode);
653 ovl_set_dir_cache(inode, cache);
654
655 return cache;
656}
657
658struct ovl_readdir_translate {
659 struct dir_context *orig_ctx;
660 struct ovl_dir_cache *cache;
661 struct dir_context ctx;
662 u64 parent_ino;
663 int fsid;
664 int xinobits;
665 bool xinowarn;
666};
667
668static bool ovl_fill_real(struct dir_context *ctx, const char *name,
669 int namelen, loff_t offset, u64 ino,
670 unsigned int d_type)
671{
672 struct ovl_readdir_translate *rdt =
673 container_of(ctx, struct ovl_readdir_translate, ctx);
674 struct dir_context *orig_ctx = rdt->orig_ctx;
675
676 if (rdt->parent_ino && strcmp(name, "..") == 0) {
677 ino = rdt->parent_ino;
678 } else if (rdt->cache) {
679 struct ovl_cache_entry *p;
680
681 p = ovl_cache_entry_find(&rdt->cache->root, name, namelen);
682 if (p)
683 ino = p->ino;
684 } else if (rdt->xinobits) {
685 ino = ovl_remap_lower_ino(ino, rdt->xinobits, rdt->fsid,
686 name, namelen, rdt->xinowarn);
687 }
688
689 return orig_ctx->actor(orig_ctx, name, namelen, offset, ino, d_type);
690}
691
692static bool ovl_is_impure_dir(struct file *file)
693{
694 struct ovl_dir_file *od = file->private_data;
695 struct inode *dir = file_inode(file);
696
697 /*
698 * Only upper dir can be impure, but if we are in the middle of
699 * iterating a lower real dir, dir could be copied up and marked
700 * impure. We only want the impure cache if we started iterating
701 * a real upper dir to begin with.
702 */
703 return od->is_upper && ovl_test_flag(OVL_IMPURE, dir);
704
705}
706
707static int ovl_iterate_real(struct file *file, struct dir_context *ctx)
708{
709 int err;
710 struct ovl_dir_file *od = file->private_data;
711 struct dentry *dir = file->f_path.dentry;
712 struct ovl_fs *ofs = OVL_FS(dir->d_sb);
713 const struct ovl_layer *lower_layer = ovl_layer_lower(dir);
714 struct ovl_readdir_translate rdt = {
715 .ctx.actor = ovl_fill_real,
716 .orig_ctx = ctx,
717 .xinobits = ovl_xino_bits(ofs),
718 .xinowarn = ovl_xino_warn(ofs),
719 };
720
721 if (rdt.xinobits && lower_layer)
722 rdt.fsid = lower_layer->fsid;
723
724 if (OVL_TYPE_MERGE(ovl_path_type(dir->d_parent))) {
725 struct kstat stat;
726 struct path statpath = file->f_path;
727
728 statpath.dentry = dir->d_parent;
729 err = vfs_getattr(&statpath, &stat, STATX_INO, 0);
730 if (err)
731 return err;
732
733 WARN_ON_ONCE(dir->d_sb->s_dev != stat.dev);
734 rdt.parent_ino = stat.ino;
735 }
736
737 if (ovl_is_impure_dir(file)) {
738 rdt.cache = ovl_cache_get_impure(&file->f_path);
739 if (IS_ERR(rdt.cache))
740 return PTR_ERR(rdt.cache);
741 }
742
743 err = iterate_dir(od->realfile, &rdt.ctx);
744 ctx->pos = rdt.ctx.pos;
745
746 return err;
747}
748
749
750static int ovl_iterate(struct file *file, struct dir_context *ctx)
751{
752 struct ovl_dir_file *od = file->private_data;
753 struct dentry *dentry = file->f_path.dentry;
754 struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
755 struct ovl_cache_entry *p;
756 const struct cred *old_cred;
757 int err;
758
759 old_cred = ovl_override_creds(dentry->d_sb);
760 if (!ctx->pos)
761 ovl_dir_reset(file);
762
763 if (od->is_real) {
764 /*
765 * If parent is merge, then need to adjust d_ino for '..', if
766 * dir is impure then need to adjust d_ino for copied up
767 * entries.
768 */
769 if (ovl_xino_bits(ofs) ||
770 (ovl_same_fs(ofs) &&
771 (ovl_is_impure_dir(file) ||
772 OVL_TYPE_MERGE(ovl_path_type(dentry->d_parent))))) {
773 err = ovl_iterate_real(file, ctx);
774 } else {
775 err = iterate_dir(od->realfile, ctx);
776 }
777 goto out;
778 }
779
780 if (!od->cache) {
781 struct ovl_dir_cache *cache;
782
783 cache = ovl_cache_get(dentry);
784 err = PTR_ERR(cache);
785 if (IS_ERR(cache))
786 goto out;
787
788 od->cache = cache;
789 ovl_seek_cursor(od, ctx->pos);
790 }
791
792 while (od->cursor != &od->cache->entries) {
793 p = list_entry(od->cursor, struct ovl_cache_entry, l_node);
794 if (!p->is_whiteout) {
795 if (!p->ino || p->check_xwhiteout) {
796 err = ovl_cache_update(&file->f_path, p, !p->ino);
797 if (err)
798 goto out;
799 }
800 }
801 /* ovl_cache_update() sets is_whiteout on stale entry */
802 if (!p->is_whiteout) {
803 if (!dir_emit(ctx, p->name, p->len, p->ino, p->type))
804 break;
805 }
806 od->cursor = p->l_node.next;
807 ctx->pos++;
808 }
809 err = 0;
810out:
811 revert_creds(old_cred);
812 return err;
813}
814
815static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin)
816{
817 loff_t res;
818 struct ovl_dir_file *od = file->private_data;
819
820 inode_lock(file_inode(file));
821 if (!file->f_pos)
822 ovl_dir_reset(file);
823
824 if (od->is_real) {
825 res = vfs_llseek(od->realfile, offset, origin);
826 file->f_pos = od->realfile->f_pos;
827 } else {
828 res = -EINVAL;
829
830 switch (origin) {
831 case SEEK_CUR:
832 offset += file->f_pos;
833 break;
834 case SEEK_SET:
835 break;
836 default:
837 goto out_unlock;
838 }
839 if (offset < 0)
840 goto out_unlock;
841
842 if (offset != file->f_pos) {
843 file->f_pos = offset;
844 if (od->cache)
845 ovl_seek_cursor(od, offset);
846 }
847 res = offset;
848 }
849out_unlock:
850 inode_unlock(file_inode(file));
851
852 return res;
853}
854
855static struct file *ovl_dir_open_realfile(const struct file *file,
856 const struct path *realpath)
857{
858 struct file *res;
859 const struct cred *old_cred;
860
861 old_cred = ovl_override_creds(file_inode(file)->i_sb);
862 res = ovl_path_open(realpath, O_RDONLY | (file->f_flags & O_LARGEFILE));
863 revert_creds(old_cred);
864
865 return res;
866}
867
868/*
869 * Like ovl_real_fdget(), returns upperfile if dir was copied up since open.
870 * Unlike ovl_real_fdget(), this caches upperfile in file->private_data.
871 *
872 * TODO: use same abstract type for file->private_data of dir and file so
873 * upperfile could also be cached for files as well.
874 */
875struct file *ovl_dir_real_file(const struct file *file, bool want_upper)
876{
877
878 struct ovl_dir_file *od = file->private_data;
879 struct dentry *dentry = file->f_path.dentry;
880 struct file *old, *realfile = od->realfile;
881
882 if (!OVL_TYPE_UPPER(ovl_path_type(dentry)))
883 return want_upper ? NULL : realfile;
884
885 /*
886 * Need to check if we started out being a lower dir, but got copied up
887 */
888 if (!od->is_upper) {
889 realfile = READ_ONCE(od->upperfile);
890 if (!realfile) {
891 struct path upperpath;
892
893 ovl_path_upper(dentry, &upperpath);
894 realfile = ovl_dir_open_realfile(file, &upperpath);
895 if (IS_ERR(realfile))
896 return realfile;
897
898 old = cmpxchg_release(&od->upperfile, NULL, realfile);
899 if (old) {
900 fput(realfile);
901 realfile = old;
902 }
903 }
904 }
905
906 return realfile;
907}
908
909static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end,
910 int datasync)
911{
912 struct file *realfile;
913 int err;
914
915 err = ovl_sync_status(OVL_FS(file_inode(file)->i_sb));
916 if (err <= 0)
917 return err;
918
919 realfile = ovl_dir_real_file(file, true);
920 err = PTR_ERR_OR_ZERO(realfile);
921
922 /* Nothing to sync for lower */
923 if (!realfile || err)
924 return err;
925
926 return vfs_fsync_range(realfile, start, end, datasync);
927}
928
929static int ovl_dir_release(struct inode *inode, struct file *file)
930{
931 struct ovl_dir_file *od = file->private_data;
932
933 if (od->cache) {
934 inode_lock(inode);
935 ovl_cache_put(od, inode);
936 inode_unlock(inode);
937 }
938 fput(od->realfile);
939 if (od->upperfile)
940 fput(od->upperfile);
941 kfree(od);
942
943 return 0;
944}
945
946static int ovl_dir_open(struct inode *inode, struct file *file)
947{
948 struct path realpath;
949 struct file *realfile;
950 struct ovl_dir_file *od;
951 enum ovl_path_type type;
952
953 od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL);
954 if (!od)
955 return -ENOMEM;
956
957 type = ovl_path_real(file->f_path.dentry, &realpath);
958 realfile = ovl_dir_open_realfile(file, &realpath);
959 if (IS_ERR(realfile)) {
960 kfree(od);
961 return PTR_ERR(realfile);
962 }
963 od->realfile = realfile;
964 od->is_real = ovl_dir_is_real(inode);
965 od->is_upper = OVL_TYPE_UPPER(type);
966 file->private_data = od;
967
968 return 0;
969}
970
971WRAP_DIR_ITER(ovl_iterate) // FIXME!
972const struct file_operations ovl_dir_operations = {
973 .read = generic_read_dir,
974 .open = ovl_dir_open,
975 .iterate_shared = shared_ovl_iterate,
976 .llseek = ovl_dir_llseek,
977 .fsync = ovl_dir_fsync,
978 .release = ovl_dir_release,
979};
980
981int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list)
982{
983 int err;
984 struct ovl_cache_entry *p, *n;
985 struct rb_root root = RB_ROOT;
986 const struct cred *old_cred;
987
988 old_cred = ovl_override_creds(dentry->d_sb);
989 err = ovl_dir_read_merged(dentry, list, &root);
990 revert_creds(old_cred);
991 if (err)
992 return err;
993
994 err = 0;
995
996 list_for_each_entry_safe(p, n, list, l_node) {
997 /*
998 * Select whiteouts in upperdir, they should
999 * be cleared when deleting this directory.
1000 */
1001 if (p->is_whiteout) {
1002 if (p->is_upper)
1003 continue;
1004 goto del_entry;
1005 }
1006
1007 if (p->name[0] == '.') {
1008 if (p->len == 1)
1009 goto del_entry;
1010 if (p->len == 2 && p->name[1] == '.')
1011 goto del_entry;
1012 }
1013 err = -ENOTEMPTY;
1014 break;
1015
1016del_entry:
1017 list_del(&p->l_node);
1018 kfree(p);
1019 }
1020
1021 return err;
1022}
1023
1024void ovl_cleanup_whiteouts(struct ovl_fs *ofs, struct dentry *upper,
1025 struct list_head *list)
1026{
1027 struct ovl_cache_entry *p;
1028
1029 inode_lock_nested(upper->d_inode, I_MUTEX_CHILD);
1030 list_for_each_entry(p, list, l_node) {
1031 struct dentry *dentry;
1032
1033 if (WARN_ON(!p->is_whiteout || !p->is_upper))
1034 continue;
1035
1036 dentry = ovl_lookup_upper(ofs, p->name, upper, p->len);
1037 if (IS_ERR(dentry)) {
1038 pr_err("lookup '%s/%.*s' failed (%i)\n",
1039 upper->d_name.name, p->len, p->name,
1040 (int) PTR_ERR(dentry));
1041 continue;
1042 }
1043 if (dentry->d_inode)
1044 ovl_cleanup(ofs, upper->d_inode, dentry);
1045 dput(dentry);
1046 }
1047 inode_unlock(upper->d_inode);
1048}
1049
1050static bool ovl_check_d_type(struct dir_context *ctx, const char *name,
1051 int namelen, loff_t offset, u64 ino,
1052 unsigned int d_type)
1053{
1054 struct ovl_readdir_data *rdd =
1055 container_of(ctx, struct ovl_readdir_data, ctx);
1056
1057 /* Even if d_type is not supported, DT_DIR is returned for . and .. */
1058 if (!strncmp(name, ".", namelen) || !strncmp(name, "..", namelen))
1059 return true;
1060
1061 if (d_type != DT_UNKNOWN)
1062 rdd->d_type_supported = true;
1063
1064 return true;
1065}
1066
1067/*
1068 * Returns 1 if d_type is supported, 0 not supported/unknown. Negative values
1069 * if error is encountered.
1070 */
1071int ovl_check_d_type_supported(const struct path *realpath)
1072{
1073 int err;
1074 struct ovl_readdir_data rdd = {
1075 .ctx.actor = ovl_check_d_type,
1076 .d_type_supported = false,
1077 };
1078
1079 err = ovl_dir_read(realpath, &rdd);
1080 if (err)
1081 return err;
1082
1083 return rdd.d_type_supported;
1084}
1085
1086#define OVL_INCOMPATDIR_NAME "incompat"
1087
1088static int ovl_workdir_cleanup_recurse(struct ovl_fs *ofs, const struct path *path,
1089 int level)
1090{
1091 int err;
1092 struct inode *dir = path->dentry->d_inode;
1093 LIST_HEAD(list);
1094 struct ovl_cache_entry *p;
1095 struct ovl_readdir_data rdd = {
1096 .ctx.actor = ovl_fill_plain,
1097 .list = &list,
1098 };
1099 bool incompat = false;
1100
1101 /*
1102 * The "work/incompat" directory is treated specially - if it is not
1103 * empty, instead of printing a generic error and mounting read-only,
1104 * we will error about incompat features and fail the mount.
1105 *
1106 * When called from ovl_indexdir_cleanup(), path->dentry->d_name.name
1107 * starts with '#'.
1108 */
1109 if (level == 2 &&
1110 !strcmp(path->dentry->d_name.name, OVL_INCOMPATDIR_NAME))
1111 incompat = true;
1112
1113 err = ovl_dir_read(path, &rdd);
1114 if (err)
1115 goto out;
1116
1117 inode_lock_nested(dir, I_MUTEX_PARENT);
1118 list_for_each_entry(p, &list, l_node) {
1119 struct dentry *dentry;
1120
1121 if (p->name[0] == '.') {
1122 if (p->len == 1)
1123 continue;
1124 if (p->len == 2 && p->name[1] == '.')
1125 continue;
1126 } else if (incompat) {
1127 pr_err("overlay with incompat feature '%s' cannot be mounted\n",
1128 p->name);
1129 err = -EINVAL;
1130 break;
1131 }
1132 dentry = ovl_lookup_upper(ofs, p->name, path->dentry, p->len);
1133 if (IS_ERR(dentry))
1134 continue;
1135 if (dentry->d_inode)
1136 err = ovl_workdir_cleanup(ofs, dir, path->mnt, dentry, level);
1137 dput(dentry);
1138 if (err)
1139 break;
1140 }
1141 inode_unlock(dir);
1142out:
1143 ovl_cache_free(&list);
1144 return err;
1145}
1146
1147int ovl_workdir_cleanup(struct ovl_fs *ofs, struct inode *dir,
1148 struct vfsmount *mnt, struct dentry *dentry, int level)
1149{
1150 int err;
1151
1152 if (!d_is_dir(dentry) || level > 1) {
1153 return ovl_cleanup(ofs, dir, dentry);
1154 }
1155
1156 err = ovl_do_rmdir(ofs, dir, dentry);
1157 if (err) {
1158 struct path path = { .mnt = mnt, .dentry = dentry };
1159
1160 inode_unlock(dir);
1161 err = ovl_workdir_cleanup_recurse(ofs, &path, level + 1);
1162 inode_lock_nested(dir, I_MUTEX_PARENT);
1163 if (!err)
1164 err = ovl_cleanup(ofs, dir, dentry);
1165 }
1166
1167 return err;
1168}
1169
1170int ovl_indexdir_cleanup(struct ovl_fs *ofs)
1171{
1172 int err;
1173 struct dentry *indexdir = ofs->workdir;
1174 struct dentry *index = NULL;
1175 struct inode *dir = indexdir->d_inode;
1176 struct path path = { .mnt = ovl_upper_mnt(ofs), .dentry = indexdir };
1177 LIST_HEAD(list);
1178 struct ovl_cache_entry *p;
1179 struct ovl_readdir_data rdd = {
1180 .ctx.actor = ovl_fill_plain,
1181 .list = &list,
1182 };
1183
1184 err = ovl_dir_read(&path, &rdd);
1185 if (err)
1186 goto out;
1187
1188 inode_lock_nested(dir, I_MUTEX_PARENT);
1189 list_for_each_entry(p, &list, l_node) {
1190 if (p->name[0] == '.') {
1191 if (p->len == 1)
1192 continue;
1193 if (p->len == 2 && p->name[1] == '.')
1194 continue;
1195 }
1196 index = ovl_lookup_upper(ofs, p->name, indexdir, p->len);
1197 if (IS_ERR(index)) {
1198 err = PTR_ERR(index);
1199 index = NULL;
1200 break;
1201 }
1202 /* Cleanup leftover from index create/cleanup attempt */
1203 if (index->d_name.name[0] == '#') {
1204 err = ovl_workdir_cleanup(ofs, dir, path.mnt, index, 1);
1205 if (err)
1206 break;
1207 goto next;
1208 }
1209 err = ovl_verify_index(ofs, index);
1210 if (!err) {
1211 goto next;
1212 } else if (err == -ESTALE) {
1213 /* Cleanup stale index entries */
1214 err = ovl_cleanup(ofs, dir, index);
1215 } else if (err != -ENOENT) {
1216 /*
1217 * Abort mount to avoid corrupting the index if
1218 * an incompatible index entry was found or on out
1219 * of memory.
1220 */
1221 break;
1222 } else if (ofs->config.nfs_export) {
1223 /*
1224 * Whiteout orphan index to block future open by
1225 * handle after overlay nlink dropped to zero.
1226 */
1227 err = ovl_cleanup_and_whiteout(ofs, dir, index);
1228 } else {
1229 /* Cleanup orphan index entries */
1230 err = ovl_cleanup(ofs, dir, index);
1231 }
1232
1233 if (err)
1234 break;
1235
1236next:
1237 dput(index);
1238 index = NULL;
1239 }
1240 dput(index);
1241 inode_unlock(dir);
1242out:
1243 ovl_cache_free(&list);
1244 if (err)
1245 pr_err("failed index dir cleanup (%i)\n", err);
1246 return err;
1247}