1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2011 Novell Inc.
4  * Copyright (C) 2016 Red Hat, Inc.
5  */
6 
7 #include <linux/fs.h>
8 #include <linux/mount.h>
9 #include <linux/slab.h>
10 #include <linux/cred.h>
11 #include <linux/xattr.h>
12 #include <linux/exportfs.h>
13 #include <linux/fileattr.h>
14 #include <linux/uuid.h>
15 #include <linux/namei.h>
16 #include <linux/ratelimit.h>
17 #include "overlayfs.h"
18 
ovl_want_write(struct dentry * dentry)19 int ovl_want_write(struct dentry *dentry)
20 {
21 	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
22 	return mnt_want_write(ovl_upper_mnt(ofs));
23 }
24 
ovl_drop_write(struct dentry * dentry)25 void ovl_drop_write(struct dentry *dentry)
26 {
27 	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
28 	mnt_drop_write(ovl_upper_mnt(ofs));
29 }
30 
ovl_workdir(struct dentry * dentry)31 struct dentry *ovl_workdir(struct dentry *dentry)
32 {
33 	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
34 	return ofs->workdir;
35 }
36 
ovl_override_creds(struct super_block * sb)37 const struct cred *ovl_override_creds(struct super_block *sb)
38 {
39 	struct ovl_fs *ofs = sb->s_fs_info;
40 
41 	return override_creds(ofs->creator_cred);
42 }
43 
44 /*
45  * Check if underlying fs supports file handles and try to determine encoding
46  * type, in order to deduce maximum inode number used by fs.
47  *
48  * Return 0 if file handles are not supported.
49  * Return 1 (FILEID_INO32_GEN) if fs uses the default 32bit inode encoding.
50  * Return -1 if fs uses a non default encoding with unknown inode size.
51  */
ovl_can_decode_fh(struct super_block * sb)52 int ovl_can_decode_fh(struct super_block *sb)
53 {
54 	if (!capable(CAP_DAC_READ_SEARCH))
55 		return 0;
56 
57 	if (!sb->s_export_op || !sb->s_export_op->fh_to_dentry)
58 		return 0;
59 
60 	return sb->s_export_op->encode_fh ? -1 : FILEID_INO32_GEN;
61 }
62 
ovl_indexdir(struct super_block * sb)63 struct dentry *ovl_indexdir(struct super_block *sb)
64 {
65 	struct ovl_fs *ofs = sb->s_fs_info;
66 
67 	return ofs->indexdir;
68 }
69 
70 /* Index all files on copy up. For now only enabled for NFS export */
ovl_index_all(struct super_block * sb)71 bool ovl_index_all(struct super_block *sb)
72 {
73 	struct ovl_fs *ofs = sb->s_fs_info;
74 
75 	return ofs->config.nfs_export && ofs->config.index;
76 }
77 
78 /* Verify lower origin on lookup. For now only enabled for NFS export */
ovl_verify_lower(struct super_block * sb)79 bool ovl_verify_lower(struct super_block *sb)
80 {
81 	struct ovl_fs *ofs = sb->s_fs_info;
82 
83 	return ofs->config.nfs_export && ofs->config.index;
84 }
85 
ovl_alloc_entry(unsigned int numlower)86 struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
87 {
88 	size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
89 	struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
90 
91 	if (oe)
92 		oe->numlower = numlower;
93 
94 	return oe;
95 }
96 
ovl_dentry_remote(struct dentry * dentry)97 bool ovl_dentry_remote(struct dentry *dentry)
98 {
99 	return dentry->d_flags &
100 		(DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE);
101 }
102 
ovl_dentry_update_reval(struct dentry * dentry,struct dentry * upperdentry,unsigned int mask)103 void ovl_dentry_update_reval(struct dentry *dentry, struct dentry *upperdentry,
104 			     unsigned int mask)
105 {
106 	struct ovl_entry *oe = OVL_E(dentry);
107 	unsigned int i, flags = 0;
108 
109 	if (upperdentry)
110 		flags |= upperdentry->d_flags;
111 	for (i = 0; i < oe->numlower; i++)
112 		flags |= oe->lowerstack[i].dentry->d_flags;
113 
114 	spin_lock(&dentry->d_lock);
115 	dentry->d_flags &= ~mask;
116 	dentry->d_flags |= flags & mask;
117 	spin_unlock(&dentry->d_lock);
118 }
119 
ovl_dentry_weird(struct dentry * dentry)120 bool ovl_dentry_weird(struct dentry *dentry)
121 {
122 	return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
123 				  DCACHE_MANAGE_TRANSIT |
124 				  DCACHE_OP_HASH |
125 				  DCACHE_OP_COMPARE);
126 }
127 
ovl_path_type(struct dentry * dentry)128 enum ovl_path_type ovl_path_type(struct dentry *dentry)
129 {
130 	struct ovl_entry *oe = dentry->d_fsdata;
131 	enum ovl_path_type type = 0;
132 
133 	if (ovl_dentry_upper(dentry)) {
134 		type = __OVL_PATH_UPPER;
135 
136 		/*
137 		 * Non-dir dentry can hold lower dentry of its copy up origin.
138 		 */
139 		if (oe->numlower) {
140 			if (ovl_test_flag(OVL_CONST_INO, d_inode(dentry)))
141 				type |= __OVL_PATH_ORIGIN;
142 			if (d_is_dir(dentry) ||
143 			    !ovl_has_upperdata(d_inode(dentry)))
144 				type |= __OVL_PATH_MERGE;
145 		}
146 	} else {
147 		if (oe->numlower > 1)
148 			type |= __OVL_PATH_MERGE;
149 	}
150 	return type;
151 }
152 
ovl_path_upper(struct dentry * dentry,struct path * path)153 void ovl_path_upper(struct dentry *dentry, struct path *path)
154 {
155 	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
156 
157 	path->mnt = ovl_upper_mnt(ofs);
158 	path->dentry = ovl_dentry_upper(dentry);
159 }
160 
ovl_path_lower(struct dentry * dentry,struct path * path)161 void ovl_path_lower(struct dentry *dentry, struct path *path)
162 {
163 	struct ovl_entry *oe = dentry->d_fsdata;
164 
165 	if (oe->numlower) {
166 		path->mnt = oe->lowerstack[0].layer->mnt;
167 		path->dentry = oe->lowerstack[0].dentry;
168 	} else {
169 		*path = (struct path) { };
170 	}
171 }
172 
ovl_path_lowerdata(struct dentry * dentry,struct path * path)173 void ovl_path_lowerdata(struct dentry *dentry, struct path *path)
174 {
175 	struct ovl_entry *oe = dentry->d_fsdata;
176 
177 	if (oe->numlower) {
178 		path->mnt = oe->lowerstack[oe->numlower - 1].layer->mnt;
179 		path->dentry = oe->lowerstack[oe->numlower - 1].dentry;
180 	} else {
181 		*path = (struct path) { };
182 	}
183 }
184 
ovl_path_real(struct dentry * dentry,struct path * path)185 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
186 {
187 	enum ovl_path_type type = ovl_path_type(dentry);
188 
189 	if (!OVL_TYPE_UPPER(type))
190 		ovl_path_lower(dentry, path);
191 	else
192 		ovl_path_upper(dentry, path);
193 
194 	return type;
195 }
196 
ovl_path_realdata(struct dentry * dentry,struct path * path)197 enum ovl_path_type ovl_path_realdata(struct dentry *dentry, struct path *path)
198 {
199 	enum ovl_path_type type = ovl_path_type(dentry);
200 
201 	WARN_ON_ONCE(d_is_dir(dentry));
202 
203 	if (!OVL_TYPE_UPPER(type) || OVL_TYPE_MERGE(type))
204 		ovl_path_lowerdata(dentry, path);
205 	else
206 		ovl_path_upper(dentry, path);
207 
208 	return type;
209 }
210 
ovl_dentry_upper(struct dentry * dentry)211 struct dentry *ovl_dentry_upper(struct dentry *dentry)
212 {
213 	return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
214 }
215 
ovl_dentry_lower(struct dentry * dentry)216 struct dentry *ovl_dentry_lower(struct dentry *dentry)
217 {
218 	struct ovl_entry *oe = dentry->d_fsdata;
219 
220 	return oe->numlower ? oe->lowerstack[0].dentry : NULL;
221 }
222 
ovl_layer_lower(struct dentry * dentry)223 const struct ovl_layer *ovl_layer_lower(struct dentry *dentry)
224 {
225 	struct ovl_entry *oe = dentry->d_fsdata;
226 
227 	return oe->numlower ? oe->lowerstack[0].layer : NULL;
228 }
229 
230 /*
231  * ovl_dentry_lower() could return either a data dentry or metacopy dentry
232  * depending on what is stored in lowerstack[0]. At times we need to find
233  * lower dentry which has data (and not metacopy dentry). This helper
234  * returns the lower data dentry.
235  */
ovl_dentry_lowerdata(struct dentry * dentry)236 struct dentry *ovl_dentry_lowerdata(struct dentry *dentry)
237 {
238 	struct ovl_entry *oe = dentry->d_fsdata;
239 
240 	return oe->numlower ? oe->lowerstack[oe->numlower - 1].dentry : NULL;
241 }
242 
ovl_dentry_real(struct dentry * dentry)243 struct dentry *ovl_dentry_real(struct dentry *dentry)
244 {
245 	return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
246 }
247 
ovl_i_dentry_upper(struct inode * inode)248 struct dentry *ovl_i_dentry_upper(struct inode *inode)
249 {
250 	return ovl_upperdentry_dereference(OVL_I(inode));
251 }
252 
ovl_i_path_real(struct inode * inode,struct path * path)253 void ovl_i_path_real(struct inode *inode, struct path *path)
254 {
255 	path->dentry = ovl_i_dentry_upper(inode);
256 	if (!path->dentry) {
257 		path->dentry = OVL_I(inode)->lowerpath.dentry;
258 		path->mnt = OVL_I(inode)->lowerpath.layer->mnt;
259 	} else {
260 		path->mnt = ovl_upper_mnt(OVL_FS(inode->i_sb));
261 	}
262 }
263 
ovl_inode_upper(struct inode * inode)264 struct inode *ovl_inode_upper(struct inode *inode)
265 {
266 	struct dentry *upperdentry = ovl_i_dentry_upper(inode);
267 
268 	return upperdentry ? d_inode(upperdentry) : NULL;
269 }
270 
ovl_inode_lower(struct inode * inode)271 struct inode *ovl_inode_lower(struct inode *inode)
272 {
273 	struct dentry *lowerdentry = OVL_I(inode)->lowerpath.dentry;
274 
275 	return lowerdentry ? d_inode(lowerdentry) : NULL;
276 }
277 
ovl_inode_real(struct inode * inode)278 struct inode *ovl_inode_real(struct inode *inode)
279 {
280 	return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
281 }
282 
283 /* Return inode which contains lower data. Do not return metacopy */
ovl_inode_lowerdata(struct inode * inode)284 struct inode *ovl_inode_lowerdata(struct inode *inode)
285 {
286 	if (WARN_ON(!S_ISREG(inode->i_mode)))
287 		return NULL;
288 
289 	return OVL_I(inode)->lowerdata ?: ovl_inode_lower(inode);
290 }
291 
292 /* Return real inode which contains data. Does not return metacopy inode */
ovl_inode_realdata(struct inode * inode)293 struct inode *ovl_inode_realdata(struct inode *inode)
294 {
295 	struct inode *upperinode;
296 
297 	upperinode = ovl_inode_upper(inode);
298 	if (upperinode && ovl_has_upperdata(inode))
299 		return upperinode;
300 
301 	return ovl_inode_lowerdata(inode);
302 }
303 
ovl_dir_cache(struct inode * inode)304 struct ovl_dir_cache *ovl_dir_cache(struct inode *inode)
305 {
306 	return OVL_I(inode)->cache;
307 }
308 
ovl_set_dir_cache(struct inode * inode,struct ovl_dir_cache * cache)309 void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache)
310 {
311 	OVL_I(inode)->cache = cache;
312 }
313 
ovl_dentry_set_flag(unsigned long flag,struct dentry * dentry)314 void ovl_dentry_set_flag(unsigned long flag, struct dentry *dentry)
315 {
316 	set_bit(flag, &OVL_E(dentry)->flags);
317 }
318 
ovl_dentry_clear_flag(unsigned long flag,struct dentry * dentry)319 void ovl_dentry_clear_flag(unsigned long flag, struct dentry *dentry)
320 {
321 	clear_bit(flag, &OVL_E(dentry)->flags);
322 }
323 
ovl_dentry_test_flag(unsigned long flag,struct dentry * dentry)324 bool ovl_dentry_test_flag(unsigned long flag, struct dentry *dentry)
325 {
326 	return test_bit(flag, &OVL_E(dentry)->flags);
327 }
328 
ovl_dentry_is_opaque(struct dentry * dentry)329 bool ovl_dentry_is_opaque(struct dentry *dentry)
330 {
331 	return ovl_dentry_test_flag(OVL_E_OPAQUE, dentry);
332 }
333 
ovl_dentry_is_whiteout(struct dentry * dentry)334 bool ovl_dentry_is_whiteout(struct dentry *dentry)
335 {
336 	return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
337 }
338 
ovl_dentry_set_opaque(struct dentry * dentry)339 void ovl_dentry_set_opaque(struct dentry *dentry)
340 {
341 	ovl_dentry_set_flag(OVL_E_OPAQUE, dentry);
342 }
343 
344 /*
345  * For hard links and decoded file handles, it's possible for ovl_dentry_upper()
346  * to return positive, while there's no actual upper alias for the inode.
347  * Copy up code needs to know about the existence of the upper alias, so it
348  * can't use ovl_dentry_upper().
349  */
ovl_dentry_has_upper_alias(struct dentry * dentry)350 bool ovl_dentry_has_upper_alias(struct dentry *dentry)
351 {
352 	return ovl_dentry_test_flag(OVL_E_UPPER_ALIAS, dentry);
353 }
354 
ovl_dentry_set_upper_alias(struct dentry * dentry)355 void ovl_dentry_set_upper_alias(struct dentry *dentry)
356 {
357 	ovl_dentry_set_flag(OVL_E_UPPER_ALIAS, dentry);
358 }
359 
ovl_should_check_upperdata(struct inode * inode)360 static bool ovl_should_check_upperdata(struct inode *inode)
361 {
362 	if (!S_ISREG(inode->i_mode))
363 		return false;
364 
365 	if (!ovl_inode_lower(inode))
366 		return false;
367 
368 	return true;
369 }
370 
ovl_has_upperdata(struct inode * inode)371 bool ovl_has_upperdata(struct inode *inode)
372 {
373 	if (!ovl_should_check_upperdata(inode))
374 		return true;
375 
376 	if (!ovl_test_flag(OVL_UPPERDATA, inode))
377 		return false;
378 	/*
379 	 * Pairs with smp_wmb() in ovl_set_upperdata(). Main user of
380 	 * ovl_has_upperdata() is ovl_copy_up_meta_inode_data(). Make sure
381 	 * if setting of OVL_UPPERDATA is visible, then effects of writes
382 	 * before that are visible too.
383 	 */
384 	smp_rmb();
385 	return true;
386 }
387 
ovl_set_upperdata(struct inode * inode)388 void ovl_set_upperdata(struct inode *inode)
389 {
390 	/*
391 	 * Pairs with smp_rmb() in ovl_has_upperdata(). Make sure
392 	 * if OVL_UPPERDATA flag is visible, then effects of write operations
393 	 * before it are visible as well.
394 	 */
395 	smp_wmb();
396 	ovl_set_flag(OVL_UPPERDATA, inode);
397 }
398 
399 /* Caller should hold ovl_inode->lock */
ovl_dentry_needs_data_copy_up_locked(struct dentry * dentry,int flags)400 bool ovl_dentry_needs_data_copy_up_locked(struct dentry *dentry, int flags)
401 {
402 	if (!ovl_open_flags_need_copy_up(flags))
403 		return false;
404 
405 	return !ovl_test_flag(OVL_UPPERDATA, d_inode(dentry));
406 }
407 
ovl_dentry_needs_data_copy_up(struct dentry * dentry,int flags)408 bool ovl_dentry_needs_data_copy_up(struct dentry *dentry, int flags)
409 {
410 	if (!ovl_open_flags_need_copy_up(flags))
411 		return false;
412 
413 	return !ovl_has_upperdata(d_inode(dentry));
414 }
415 
ovl_redirect_dir(struct super_block * sb)416 bool ovl_redirect_dir(struct super_block *sb)
417 {
418 	struct ovl_fs *ofs = sb->s_fs_info;
419 
420 	return ofs->config.redirect_dir && !ofs->noxattr;
421 }
422 
ovl_dentry_get_redirect(struct dentry * dentry)423 const char *ovl_dentry_get_redirect(struct dentry *dentry)
424 {
425 	return OVL_I(d_inode(dentry))->redirect;
426 }
427 
ovl_dentry_set_redirect(struct dentry * dentry,const char * redirect)428 void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect)
429 {
430 	struct ovl_inode *oi = OVL_I(d_inode(dentry));
431 
432 	kfree(oi->redirect);
433 	oi->redirect = redirect;
434 }
435 
ovl_inode_update(struct inode * inode,struct dentry * upperdentry)436 void ovl_inode_update(struct inode *inode, struct dentry *upperdentry)
437 {
438 	struct inode *upperinode = d_inode(upperdentry);
439 
440 	WARN_ON(OVL_I(inode)->__upperdentry);
441 
442 	/*
443 	 * Make sure upperdentry is consistent before making it visible
444 	 */
445 	smp_wmb();
446 	OVL_I(inode)->__upperdentry = upperdentry;
447 	if (inode_unhashed(inode)) {
448 		inode->i_private = upperinode;
449 		__insert_inode_hash(inode, (unsigned long) upperinode);
450 	}
451 }
452 
ovl_dir_version_inc(struct dentry * dentry,bool impurity)453 static void ovl_dir_version_inc(struct dentry *dentry, bool impurity)
454 {
455 	struct inode *inode = d_inode(dentry);
456 
457 	WARN_ON(!inode_is_locked(inode));
458 	WARN_ON(!d_is_dir(dentry));
459 	/*
460 	 * Version is used by readdir code to keep cache consistent.
461 	 * For merge dirs (or dirs with origin) all changes need to be noted.
462 	 * For non-merge dirs, cache contains only impure entries (i.e. ones
463 	 * which have been copied up and have origins), so only need to note
464 	 * changes to impure entries.
465 	 */
466 	if (!ovl_dir_is_real(dentry) || impurity)
467 		OVL_I(inode)->version++;
468 }
469 
ovl_dir_modified(struct dentry * dentry,bool impurity)470 void ovl_dir_modified(struct dentry *dentry, bool impurity)
471 {
472 	/* Copy mtime/ctime */
473 	ovl_copyattr(d_inode(dentry));
474 
475 	ovl_dir_version_inc(dentry, impurity);
476 }
477 
ovl_dentry_version_get(struct dentry * dentry)478 u64 ovl_dentry_version_get(struct dentry *dentry)
479 {
480 	struct inode *inode = d_inode(dentry);
481 
482 	WARN_ON(!inode_is_locked(inode));
483 	return OVL_I(inode)->version;
484 }
485 
ovl_is_whiteout(struct dentry * dentry)486 bool ovl_is_whiteout(struct dentry *dentry)
487 {
488 	struct inode *inode = dentry->d_inode;
489 
490 	return inode && IS_WHITEOUT(inode);
491 }
492 
ovl_path_open(struct path * path,int flags)493 struct file *ovl_path_open(struct path *path, int flags)
494 {
495 	struct inode *inode = d_inode(path->dentry);
496 	struct user_namespace *real_mnt_userns = mnt_user_ns(path->mnt);
497 	int err, acc_mode;
498 
499 	if (flags & ~(O_ACCMODE | O_LARGEFILE))
500 		BUG();
501 
502 	switch (flags & O_ACCMODE) {
503 	case O_RDONLY:
504 		acc_mode = MAY_READ;
505 		break;
506 	case O_WRONLY:
507 		acc_mode = MAY_WRITE;
508 		break;
509 	default:
510 		BUG();
511 	}
512 
513 	err = inode_permission(real_mnt_userns, inode, acc_mode | MAY_OPEN);
514 	if (err)
515 		return ERR_PTR(err);
516 
517 	/* O_NOATIME is an optimization, don't fail if not permitted */
518 	if (inode_owner_or_capable(real_mnt_userns, inode))
519 		flags |= O_NOATIME;
520 
521 	return dentry_open(path, flags, current_cred());
522 }
523 
524 /* Caller should hold ovl_inode->lock */
ovl_already_copied_up_locked(struct dentry * dentry,int flags)525 static bool ovl_already_copied_up_locked(struct dentry *dentry, int flags)
526 {
527 	bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED;
528 
529 	if (ovl_dentry_upper(dentry) &&
530 	    (ovl_dentry_has_upper_alias(dentry) || disconnected) &&
531 	    !ovl_dentry_needs_data_copy_up_locked(dentry, flags))
532 		return true;
533 
534 	return false;
535 }
536 
ovl_already_copied_up(struct dentry * dentry,int flags)537 bool ovl_already_copied_up(struct dentry *dentry, int flags)
538 {
539 	bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED;
540 
541 	/*
542 	 * Check if copy-up has happened as well as for upper alias (in
543 	 * case of hard links) is there.
544 	 *
545 	 * Both checks are lockless:
546 	 *  - false negatives: will recheck under oi->lock
547 	 *  - false positives:
548 	 *    + ovl_dentry_upper() uses memory barriers to ensure the
549 	 *      upper dentry is up-to-date
550 	 *    + ovl_dentry_has_upper_alias() relies on locking of
551 	 *      upper parent i_rwsem to prevent reordering copy-up
552 	 *      with rename.
553 	 */
554 	if (ovl_dentry_upper(dentry) &&
555 	    (ovl_dentry_has_upper_alias(dentry) || disconnected) &&
556 	    !ovl_dentry_needs_data_copy_up(dentry, flags))
557 		return true;
558 
559 	return false;
560 }
561 
ovl_copy_up_start(struct dentry * dentry,int flags)562 int ovl_copy_up_start(struct dentry *dentry, int flags)
563 {
564 	struct inode *inode = d_inode(dentry);
565 	int err;
566 
567 	err = ovl_inode_lock_interruptible(inode);
568 	if (!err && ovl_already_copied_up_locked(dentry, flags)) {
569 		err = 1; /* Already copied up */
570 		ovl_inode_unlock(inode);
571 	}
572 
573 	return err;
574 }
575 
ovl_copy_up_end(struct dentry * dentry)576 void ovl_copy_up_end(struct dentry *dentry)
577 {
578 	ovl_inode_unlock(d_inode(dentry));
579 }
580 
ovl_path_check_origin_xattr(struct ovl_fs * ofs,struct path * path)581 bool ovl_path_check_origin_xattr(struct ovl_fs *ofs, struct path *path)
582 {
583 	int res;
584 
585 	res = ovl_path_getxattr(ofs, path, OVL_XATTR_ORIGIN, NULL, 0);
586 
587 	/* Zero size value means "copied up but origin unknown" */
588 	if (res >= 0)
589 		return true;
590 
591 	return false;
592 }
593 
ovl_path_check_dir_xattr(struct ovl_fs * ofs,struct path * path,enum ovl_xattr ox)594 bool ovl_path_check_dir_xattr(struct ovl_fs *ofs, struct path *path,
595 			       enum ovl_xattr ox)
596 {
597 	int res;
598 	char val;
599 
600 	if (!d_is_dir(path->dentry))
601 		return false;
602 
603 	res = ovl_path_getxattr(ofs, path, ox, &val, 1);
604 	if (res == 1 && val == 'y')
605 		return true;
606 
607 	return false;
608 }
609 
610 #define OVL_XATTR_OPAQUE_POSTFIX	"opaque"
611 #define OVL_XATTR_REDIRECT_POSTFIX	"redirect"
612 #define OVL_XATTR_ORIGIN_POSTFIX	"origin"
613 #define OVL_XATTR_IMPURE_POSTFIX	"impure"
614 #define OVL_XATTR_NLINK_POSTFIX		"nlink"
615 #define OVL_XATTR_UPPER_POSTFIX		"upper"
616 #define OVL_XATTR_METACOPY_POSTFIX	"metacopy"
617 #define OVL_XATTR_PROTATTR_POSTFIX	"protattr"
618 
619 #define OVL_XATTR_TAB_ENTRY(x) \
620 	[x] = { [false] = OVL_XATTR_TRUSTED_PREFIX x ## _POSTFIX, \
621 		[true] = OVL_XATTR_USER_PREFIX x ## _POSTFIX }
622 
623 const char *const ovl_xattr_table[][2] = {
624 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_OPAQUE),
625 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_REDIRECT),
626 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_ORIGIN),
627 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_IMPURE),
628 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_NLINK),
629 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_UPPER),
630 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_METACOPY),
631 	OVL_XATTR_TAB_ENTRY(OVL_XATTR_PROTATTR),
632 };
633 
ovl_check_setxattr(struct ovl_fs * ofs,struct dentry * upperdentry,enum ovl_xattr ox,const void * value,size_t size,int xerr)634 int ovl_check_setxattr(struct ovl_fs *ofs, struct dentry *upperdentry,
635 		       enum ovl_xattr ox, const void *value, size_t size,
636 		       int xerr)
637 {
638 	int err;
639 
640 	if (ofs->noxattr)
641 		return xerr;
642 
643 	err = ovl_setxattr(ofs, upperdentry, ox, value, size);
644 
645 	if (err == -EOPNOTSUPP) {
646 		pr_warn("cannot set %s xattr on upper\n", ovl_xattr(ofs, ox));
647 		ofs->noxattr = true;
648 		return xerr;
649 	}
650 
651 	return err;
652 }
653 
ovl_set_impure(struct dentry * dentry,struct dentry * upperdentry)654 int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry)
655 {
656 	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
657 	int err;
658 
659 	if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
660 		return 0;
661 
662 	/*
663 	 * Do not fail when upper doesn't support xattrs.
664 	 * Upper inodes won't have origin nor redirect xattr anyway.
665 	 */
666 	err = ovl_check_setxattr(ofs, upperdentry, OVL_XATTR_IMPURE, "y", 1, 0);
667 	if (!err)
668 		ovl_set_flag(OVL_IMPURE, d_inode(dentry));
669 
670 	return err;
671 }
672 
673 
674 #define OVL_PROTATTR_MAX 32 /* Reserved for future flags */
675 
ovl_check_protattr(struct inode * inode,struct dentry * upper)676 void ovl_check_protattr(struct inode *inode, struct dentry *upper)
677 {
678 	struct ovl_fs *ofs = OVL_FS(inode->i_sb);
679 	u32 iflags = inode->i_flags & OVL_PROT_I_FLAGS_MASK;
680 	char buf[OVL_PROTATTR_MAX+1];
681 	int res, n;
682 
683 	res = ovl_getxattr_upper(ofs, upper, OVL_XATTR_PROTATTR, buf,
684 				 OVL_PROTATTR_MAX);
685 	if (res < 0)
686 		return;
687 
688 	/*
689 	 * Initialize inode flags from overlay.protattr xattr and upper inode
690 	 * flags.  If upper inode has those fileattr flags set (i.e. from old
691 	 * kernel), we do not clear them on ovl_get_inode(), but we will clear
692 	 * them on next fileattr_set().
693 	 */
694 	for (n = 0; n < res; n++) {
695 		if (buf[n] == 'a')
696 			iflags |= S_APPEND;
697 		else if (buf[n] == 'i')
698 			iflags |= S_IMMUTABLE;
699 		else
700 			break;
701 	}
702 
703 	if (!res || n < res) {
704 		pr_warn_ratelimited("incompatible overlay.protattr format (%pd2, len=%d)\n",
705 				    upper, res);
706 	} else {
707 		inode_set_flags(inode, iflags, OVL_PROT_I_FLAGS_MASK);
708 	}
709 }
710 
ovl_set_protattr(struct inode * inode,struct dentry * upper,struct fileattr * fa)711 int ovl_set_protattr(struct inode *inode, struct dentry *upper,
712 		      struct fileattr *fa)
713 {
714 	struct ovl_fs *ofs = OVL_FS(inode->i_sb);
715 	char buf[OVL_PROTATTR_MAX];
716 	int len = 0, err = 0;
717 	u32 iflags = 0;
718 
719 	BUILD_BUG_ON(HWEIGHT32(OVL_PROT_FS_FLAGS_MASK) > OVL_PROTATTR_MAX);
720 
721 	if (fa->flags & FS_APPEND_FL) {
722 		buf[len++] = 'a';
723 		iflags |= S_APPEND;
724 	}
725 	if (fa->flags & FS_IMMUTABLE_FL) {
726 		buf[len++] = 'i';
727 		iflags |= S_IMMUTABLE;
728 	}
729 
730 	/*
731 	 * Do not allow to set protection flags when upper doesn't support
732 	 * xattrs, because we do not set those fileattr flags on upper inode.
733 	 * Remove xattr if it exist and all protection flags are cleared.
734 	 */
735 	if (len) {
736 		err = ovl_check_setxattr(ofs, upper, OVL_XATTR_PROTATTR,
737 					 buf, len, -EPERM);
738 	} else if (inode->i_flags & OVL_PROT_I_FLAGS_MASK) {
739 		err = ovl_removexattr(ofs, upper, OVL_XATTR_PROTATTR);
740 		if (err == -EOPNOTSUPP || err == -ENODATA)
741 			err = 0;
742 	}
743 	if (err)
744 		return err;
745 
746 	inode_set_flags(inode, iflags, OVL_PROT_I_FLAGS_MASK);
747 
748 	/* Mask out the fileattr flags that should not be set in upper inode */
749 	fa->flags &= ~OVL_PROT_FS_FLAGS_MASK;
750 	fa->fsx_xflags &= ~OVL_PROT_FSX_FLAGS_MASK;
751 
752 	return 0;
753 }
754 
755 /**
756  * Caller must hold a reference to inode to prevent it from being freed while
757  * it is marked inuse.
758  */
ovl_inuse_trylock(struct dentry * dentry)759 bool ovl_inuse_trylock(struct dentry *dentry)
760 {
761 	struct inode *inode = d_inode(dentry);
762 	bool locked = false;
763 
764 	spin_lock(&inode->i_lock);
765 	if (!(inode->i_state & I_OVL_INUSE)) {
766 		inode->i_state |= I_OVL_INUSE;
767 		locked = true;
768 	}
769 	spin_unlock(&inode->i_lock);
770 
771 	return locked;
772 }
773 
ovl_inuse_unlock(struct dentry * dentry)774 void ovl_inuse_unlock(struct dentry *dentry)
775 {
776 	if (dentry) {
777 		struct inode *inode = d_inode(dentry);
778 
779 		spin_lock(&inode->i_lock);
780 		WARN_ON(!(inode->i_state & I_OVL_INUSE));
781 		inode->i_state &= ~I_OVL_INUSE;
782 		spin_unlock(&inode->i_lock);
783 	}
784 }
785 
ovl_is_inuse(struct dentry * dentry)786 bool ovl_is_inuse(struct dentry *dentry)
787 {
788 	struct inode *inode = d_inode(dentry);
789 	bool inuse;
790 
791 	spin_lock(&inode->i_lock);
792 	inuse = (inode->i_state & I_OVL_INUSE);
793 	spin_unlock(&inode->i_lock);
794 
795 	return inuse;
796 }
797 
798 /*
799  * Does this overlay dentry need to be indexed on copy up?
800  */
ovl_need_index(struct dentry * dentry)801 bool ovl_need_index(struct dentry *dentry)
802 {
803 	struct dentry *lower = ovl_dentry_lower(dentry);
804 
805 	if (!lower || !ovl_indexdir(dentry->d_sb))
806 		return false;
807 
808 	/* Index all files for NFS export and consistency verification */
809 	if (ovl_index_all(dentry->d_sb))
810 		return true;
811 
812 	/* Index only lower hardlinks on copy up */
813 	if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1)
814 		return true;
815 
816 	return false;
817 }
818 
819 /* Caller must hold OVL_I(inode)->lock */
ovl_cleanup_index(struct dentry * dentry)820 static void ovl_cleanup_index(struct dentry *dentry)
821 {
822 	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
823 	struct dentry *indexdir = ovl_indexdir(dentry->d_sb);
824 	struct inode *dir = indexdir->d_inode;
825 	struct dentry *lowerdentry = ovl_dentry_lower(dentry);
826 	struct dentry *upperdentry = ovl_dentry_upper(dentry);
827 	struct dentry *index = NULL;
828 	struct inode *inode;
829 	struct qstr name = { };
830 	int err;
831 
832 	err = ovl_get_index_name(ofs, lowerdentry, &name);
833 	if (err)
834 		goto fail;
835 
836 	inode = d_inode(upperdentry);
837 	if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) {
838 		pr_warn_ratelimited("cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
839 				    upperdentry, inode->i_ino, inode->i_nlink);
840 		/*
841 		 * We either have a bug with persistent union nlink or a lower
842 		 * hardlink was added while overlay is mounted. Adding a lower
843 		 * hardlink and then unlinking all overlay hardlinks would drop
844 		 * overlay nlink to zero before all upper inodes are unlinked.
845 		 * As a safety measure, when that situation is detected, set
846 		 * the overlay nlink to the index inode nlink minus one for the
847 		 * index entry itself.
848 		 */
849 		set_nlink(d_inode(dentry), inode->i_nlink - 1);
850 		ovl_set_nlink_upper(dentry);
851 		goto out;
852 	}
853 
854 	inode_lock_nested(dir, I_MUTEX_PARENT);
855 	index = ovl_lookup_upper(ofs, name.name, indexdir, name.len);
856 	err = PTR_ERR(index);
857 	if (IS_ERR(index)) {
858 		index = NULL;
859 	} else if (ovl_index_all(dentry->d_sb)) {
860 		/* Whiteout orphan index to block future open by handle */
861 		err = ovl_cleanup_and_whiteout(OVL_FS(dentry->d_sb),
862 					       dir, index);
863 	} else {
864 		/* Cleanup orphan index entries */
865 		err = ovl_cleanup(ofs, dir, index);
866 	}
867 
868 	inode_unlock(dir);
869 	if (err)
870 		goto fail;
871 
872 out:
873 	kfree(name.name);
874 	dput(index);
875 	return;
876 
877 fail:
878 	pr_err("cleanup index of '%pd2' failed (%i)\n", dentry, err);
879 	goto out;
880 }
881 
882 /*
883  * Operations that change overlay inode and upper inode nlink need to be
884  * synchronized with copy up for persistent nlink accounting.
885  */
ovl_nlink_start(struct dentry * dentry)886 int ovl_nlink_start(struct dentry *dentry)
887 {
888 	struct inode *inode = d_inode(dentry);
889 	const struct cred *old_cred;
890 	int err;
891 
892 	if (WARN_ON(!inode))
893 		return -ENOENT;
894 
895 	/*
896 	 * With inodes index is enabled, we store the union overlay nlink
897 	 * in an xattr on the index inode. When whiting out an indexed lower,
898 	 * we need to decrement the overlay persistent nlink, but before the
899 	 * first copy up, we have no upper index inode to store the xattr.
900 	 *
901 	 * As a workaround, before whiteout/rename over an indexed lower,
902 	 * copy up to create the upper index. Creating the upper index will
903 	 * initialize the overlay nlink, so it could be dropped if unlink
904 	 * or rename succeeds.
905 	 *
906 	 * TODO: implement metadata only index copy up when called with
907 	 *       ovl_copy_up_flags(dentry, O_PATH).
908 	 */
909 	if (ovl_need_index(dentry) && !ovl_dentry_has_upper_alias(dentry)) {
910 		err = ovl_copy_up(dentry);
911 		if (err)
912 			return err;
913 	}
914 
915 	err = ovl_inode_lock_interruptible(inode);
916 	if (err)
917 		return err;
918 
919 	if (d_is_dir(dentry) || !ovl_test_flag(OVL_INDEX, inode))
920 		goto out;
921 
922 	old_cred = ovl_override_creds(dentry->d_sb);
923 	/*
924 	 * The overlay inode nlink should be incremented/decremented IFF the
925 	 * upper operation succeeds, along with nlink change of upper inode.
926 	 * Therefore, before link/unlink/rename, we store the union nlink
927 	 * value relative to the upper inode nlink in an upper inode xattr.
928 	 */
929 	err = ovl_set_nlink_upper(dentry);
930 	revert_creds(old_cred);
931 
932 out:
933 	if (err)
934 		ovl_inode_unlock(inode);
935 
936 	return err;
937 }
938 
ovl_nlink_end(struct dentry * dentry)939 void ovl_nlink_end(struct dentry *dentry)
940 {
941 	struct inode *inode = d_inode(dentry);
942 
943 	if (ovl_test_flag(OVL_INDEX, inode) && inode->i_nlink == 0) {
944 		const struct cred *old_cred;
945 
946 		old_cred = ovl_override_creds(dentry->d_sb);
947 		ovl_cleanup_index(dentry);
948 		revert_creds(old_cred);
949 	}
950 
951 	ovl_inode_unlock(inode);
952 }
953 
ovl_lock_rename_workdir(struct dentry * workdir,struct dentry * upperdir)954 int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir)
955 {
956 	/* Workdir should not be the same as upperdir */
957 	if (workdir == upperdir)
958 		goto err;
959 
960 	/* Workdir should not be subdir of upperdir and vice versa */
961 	if (lock_rename(workdir, upperdir) != NULL)
962 		goto err_unlock;
963 
964 	return 0;
965 
966 err_unlock:
967 	unlock_rename(workdir, upperdir);
968 err:
969 	pr_err("failed to lock workdir+upperdir\n");
970 	return -EIO;
971 }
972 
973 /* err < 0, 0 if no metacopy xattr, 1 if metacopy xattr found */
ovl_check_metacopy_xattr(struct ovl_fs * ofs,struct path * path)974 int ovl_check_metacopy_xattr(struct ovl_fs *ofs, struct path *path)
975 {
976 	int res;
977 
978 	/* Only regular files can have metacopy xattr */
979 	if (!S_ISREG(d_inode(path->dentry)->i_mode))
980 		return 0;
981 
982 	res = ovl_path_getxattr(ofs, path, OVL_XATTR_METACOPY, NULL, 0);
983 	if (res < 0) {
984 		if (res == -ENODATA || res == -EOPNOTSUPP)
985 			return 0;
986 		/*
987 		 * getxattr on user.* may fail with EACCES in case there's no
988 		 * read permission on the inode.  Not much we can do, other than
989 		 * tell the caller that this is not a metacopy inode.
990 		 */
991 		if (ofs->config.userxattr && res == -EACCES)
992 			return 0;
993 		goto out;
994 	}
995 
996 	return 1;
997 out:
998 	pr_warn_ratelimited("failed to get metacopy (%i)\n", res);
999 	return res;
1000 }
1001 
ovl_is_metacopy_dentry(struct dentry * dentry)1002 bool ovl_is_metacopy_dentry(struct dentry *dentry)
1003 {
1004 	struct ovl_entry *oe = dentry->d_fsdata;
1005 
1006 	if (!d_is_reg(dentry))
1007 		return false;
1008 
1009 	if (ovl_dentry_upper(dentry)) {
1010 		if (!ovl_has_upperdata(d_inode(dentry)))
1011 			return true;
1012 		return false;
1013 	}
1014 
1015 	return (oe->numlower > 1);
1016 }
1017 
ovl_get_redirect_xattr(struct ovl_fs * ofs,struct path * path,int padding)1018 char *ovl_get_redirect_xattr(struct ovl_fs *ofs, struct path *path, int padding)
1019 {
1020 	int res;
1021 	char *s, *next, *buf = NULL;
1022 
1023 	res = ovl_path_getxattr(ofs, path, OVL_XATTR_REDIRECT, NULL, 0);
1024 	if (res == -ENODATA || res == -EOPNOTSUPP)
1025 		return NULL;
1026 	if (res < 0)
1027 		goto fail;
1028 	if (res == 0)
1029 		goto invalid;
1030 
1031 	buf = kzalloc(res + padding + 1, GFP_KERNEL);
1032 	if (!buf)
1033 		return ERR_PTR(-ENOMEM);
1034 
1035 	res = ovl_path_getxattr(ofs, path, OVL_XATTR_REDIRECT, buf, res);
1036 	if (res < 0)
1037 		goto fail;
1038 	if (res == 0)
1039 		goto invalid;
1040 
1041 	if (buf[0] == '/') {
1042 		for (s = buf; *s++ == '/'; s = next) {
1043 			next = strchrnul(s, '/');
1044 			if (s == next)
1045 				goto invalid;
1046 		}
1047 	} else {
1048 		if (strchr(buf, '/') != NULL)
1049 			goto invalid;
1050 	}
1051 
1052 	return buf;
1053 invalid:
1054 	pr_warn_ratelimited("invalid redirect (%s)\n", buf);
1055 	res = -EINVAL;
1056 	goto err_free;
1057 fail:
1058 	pr_warn_ratelimited("failed to get redirect (%i)\n", res);
1059 err_free:
1060 	kfree(buf);
1061 	return ERR_PTR(res);
1062 }
1063 
1064 /*
1065  * ovl_sync_status() - Check fs sync status for volatile mounts
1066  *
1067  * Returns 1 if this is not a volatile mount and a real sync is required.
1068  *
1069  * Returns 0 if syncing can be skipped because mount is volatile, and no errors
1070  * have occurred on the upperdir since the mount.
1071  *
1072  * Returns -errno if it is a volatile mount, and the error that occurred since
1073  * the last mount. If the error code changes, it'll return the latest error
1074  * code.
1075  */
1076 
ovl_sync_status(struct ovl_fs * ofs)1077 int ovl_sync_status(struct ovl_fs *ofs)
1078 {
1079 	struct vfsmount *mnt;
1080 
1081 	if (ovl_should_sync(ofs))
1082 		return 1;
1083 
1084 	mnt = ovl_upper_mnt(ofs);
1085 	if (!mnt)
1086 		return 0;
1087 
1088 	return errseq_check(&mnt->mnt_sb->s_wb_err, ofs->errseq);
1089 }
1090 
1091 /*
1092  * ovl_copyattr() - copy inode attributes from layer to ovl inode
1093  *
1094  * When overlay copies inode information from an upper or lower layer to the
1095  * relevant overlay inode it will apply the idmapping of the upper or lower
1096  * layer when doing so ensuring that the ovl inode ownership will correctly
1097  * reflect the ownership of the idmapped upper or lower layer. For example, an
1098  * idmapped upper or lower layer mapping id 1001 to id 1000 will take care to
1099  * map any lower or upper inode owned by id 1001 to id 1000. These mapping
1100  * helpers are nops when the relevant layer isn't idmapped.
1101  */
ovl_copyattr(struct inode * inode)1102 void ovl_copyattr(struct inode *inode)
1103 {
1104 	struct path realpath;
1105 	struct inode *realinode;
1106 	struct user_namespace *real_mnt_userns;
1107 
1108 	ovl_i_path_real(inode, &realpath);
1109 	realinode = d_inode(realpath.dentry);
1110 	real_mnt_userns = mnt_user_ns(realpath.mnt);
1111 
1112 	inode->i_uid = i_uid_into_mnt(real_mnt_userns, realinode);
1113 	inode->i_gid = i_gid_into_mnt(real_mnt_userns, realinode);
1114 	inode->i_mode = realinode->i_mode;
1115 	inode->i_atime = realinode->i_atime;
1116 	inode->i_mtime = realinode->i_mtime;
1117 	inode->i_ctime = realinode->i_ctime;
1118 	i_size_write(inode, i_size_read(realinode));
1119 }
1120