Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
bbb1e54d MS |
2 | /* |
3 | * Copyright (C) 2011 Novell Inc. | |
4 | * Copyright (C) 2016 Red Hat, Inc. | |
bbb1e54d MS |
5 | */ |
6 | ||
7 | #include <linux/fs.h> | |
8 | #include <linux/mount.h> | |
9 | #include <linux/slab.h> | |
5b825c3a | 10 | #include <linux/cred.h> |
bbb1e54d | 11 | #include <linux/xattr.h> |
02bcd157 | 12 | #include <linux/exportfs.h> |
184996e9 | 13 | #include <linux/file.h> |
096a218a | 14 | #include <linux/fileattr.h> |
02bcd157 | 15 | #include <linux/uuid.h> |
caf70cb2 AG |
16 | #include <linux/namei.h> |
17 | #include <linux/ratelimit.h> | |
bbb1e54d | 18 | #include "overlayfs.h" |
bbb1e54d | 19 | |
d08d3b3c AG |
20 | /* Get write access to upper mnt - may fail if upper sb was remounted ro */ |
21 | int ovl_get_write_access(struct dentry *dentry) | |
22 | { | |
23 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); | |
24 | return mnt_get_write_access(ovl_upper_mnt(ofs)); | |
25 | } | |
26 | ||
27 | /* Get write access to upper sb - may block if upper sb is frozen */ | |
28 | void ovl_start_write(struct dentry *dentry) | |
29 | { | |
30 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); | |
31 | sb_start_write(ovl_upper_mnt(ofs)->mnt_sb); | |
32 | } | |
33 | ||
bbb1e54d MS |
34 | int ovl_want_write(struct dentry *dentry) |
35 | { | |
f01d0889 | 36 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); |
08f4c7c8 | 37 | return mnt_want_write(ovl_upper_mnt(ofs)); |
bbb1e54d MS |
38 | } |
39 | ||
d08d3b3c AG |
40 | void ovl_put_write_access(struct dentry *dentry) |
41 | { | |
42 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); | |
43 | mnt_put_write_access(ovl_upper_mnt(ofs)); | |
44 | } | |
45 | ||
46 | void ovl_end_write(struct dentry *dentry) | |
47 | { | |
48 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); | |
49 | sb_end_write(ovl_upper_mnt(ofs)->mnt_sb); | |
50 | } | |
51 | ||
bbb1e54d MS |
52 | void ovl_drop_write(struct dentry *dentry) |
53 | { | |
f01d0889 | 54 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); |
08f4c7c8 | 55 | mnt_drop_write(ovl_upper_mnt(ofs)); |
bbb1e54d MS |
56 | } |
57 | ||
58 | struct dentry *ovl_workdir(struct dentry *dentry) | |
59 | { | |
f01d0889 | 60 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); |
bbb1e54d MS |
61 | return ofs->workdir; |
62 | } | |
63 | ||
64 | const struct cred *ovl_override_creds(struct super_block *sb) | |
65 | { | |
f01d0889 | 66 | struct ovl_fs *ofs = OVL_FS(sb); |
bbb1e54d MS |
67 | |
68 | return override_creds(ofs->creator_cred); | |
69 | } | |
70 | ||
e487d889 AG |
71 | /* |
72 | * Check if underlying fs supports file handles and try to determine encoding | |
73 | * type, in order to deduce maximum inode number used by fs. | |
74 | * | |
75 | * Return 0 if file handles are not supported. | |
76 | * Return 1 (FILEID_INO32_GEN) if fs uses the default 32bit inode encoding. | |
77 | * Return -1 if fs uses a non default encoding with unknown inode size. | |
78 | */ | |
79 | int ovl_can_decode_fh(struct super_block *sb) | |
02bcd157 | 80 | { |
c846af05 MS |
81 | if (!capable(CAP_DAC_READ_SEARCH)) |
82 | return 0; | |
83 | ||
66c62769 | 84 | if (!exportfs_can_decode_fh(sb->s_export_op)) |
e487d889 AG |
85 | return 0; |
86 | ||
87 | return sb->s_export_op->encode_fh ? -1 : FILEID_INO32_GEN; | |
02bcd157 AG |
88 | } |
89 | ||
90 | struct dentry *ovl_indexdir(struct super_block *sb) | |
91 | { | |
f01d0889 | 92 | struct ovl_fs *ofs = OVL_FS(sb); |
02bcd157 | 93 | |
02d70090 | 94 | return ofs->config.index ? ofs->workdir : NULL; |
02bcd157 AG |
95 | } |
96 | ||
f168f109 AG |
97 | /* Index all files on copy up. For now only enabled for NFS export */ |
98 | bool ovl_index_all(struct super_block *sb) | |
99 | { | |
f01d0889 | 100 | struct ovl_fs *ofs = OVL_FS(sb); |
f168f109 AG |
101 | |
102 | return ofs->config.nfs_export && ofs->config.index; | |
103 | } | |
104 | ||
105 | /* Verify lower origin on lookup. For now only enabled for NFS export */ | |
106 | bool ovl_verify_lower(struct super_block *sb) | |
107 | { | |
f01d0889 | 108 | struct ovl_fs *ofs = OVL_FS(sb); |
f168f109 AG |
109 | |
110 | return ofs->config.nfs_export && ofs->config.index; | |
111 | } | |
112 | ||
163db0da AG |
113 | struct ovl_path *ovl_stack_alloc(unsigned int n) |
114 | { | |
115 | return kcalloc(n, sizeof(struct ovl_path), GFP_KERNEL); | |
116 | } | |
117 | ||
118 | void ovl_stack_cpy(struct ovl_path *dst, struct ovl_path *src, unsigned int n) | |
119 | { | |
120 | unsigned int i; | |
121 | ||
122 | memcpy(dst, src, sizeof(struct ovl_path) * n); | |
123 | for (i = 0; i < n; i++) | |
124 | dget(src[i].dentry); | |
125 | } | |
126 | ||
127 | void ovl_stack_put(struct ovl_path *stack, unsigned int n) | |
128 | { | |
129 | unsigned int i; | |
130 | ||
131 | for (i = 0; stack && i < n; i++) | |
132 | dput(stack[i].dentry); | |
133 | } | |
134 | ||
135 | void ovl_stack_free(struct ovl_path *stack, unsigned int n) | |
136 | { | |
137 | ovl_stack_put(stack, n); | |
138 | kfree(stack); | |
139 | } | |
140 | ||
bbb1e54d MS |
141 | struct ovl_entry *ovl_alloc_entry(unsigned int numlower) |
142 | { | |
5522c9c7 | 143 | size_t size = offsetof(struct ovl_entry, __lowerstack[numlower]); |
bbb1e54d MS |
144 | struct ovl_entry *oe = kzalloc(size, GFP_KERNEL); |
145 | ||
146 | if (oe) | |
5522c9c7 | 147 | oe->__numlower = numlower; |
bbb1e54d MS |
148 | |
149 | return oe; | |
150 | } | |
151 | ||
163db0da AG |
152 | void ovl_free_entry(struct ovl_entry *oe) |
153 | { | |
154 | ovl_stack_put(ovl_lowerstack(oe), ovl_numlower(oe)); | |
155 | kfree(oe); | |
156 | } | |
157 | ||
b07d5cc9 AG |
158 | #define OVL_D_REVALIDATE (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE) |
159 | ||
bbb1e54d MS |
160 | bool ovl_dentry_remote(struct dentry *dentry) |
161 | { | |
b07d5cc9 AG |
162 | return dentry->d_flags & OVL_D_REVALIDATE; |
163 | } | |
164 | ||
165 | void ovl_dentry_update_reval(struct dentry *dentry, struct dentry *realdentry) | |
166 | { | |
167 | if (!ovl_dentry_remote(realdentry)) | |
168 | return; | |
169 | ||
170 | spin_lock(&dentry->d_lock); | |
171 | dentry->d_flags |= realdentry->d_flags & OVL_D_REVALIDATE; | |
172 | spin_unlock(&dentry->d_lock); | |
173 | } | |
174 | ||
0af950f5 AG |
175 | void ovl_dentry_init_reval(struct dentry *dentry, struct dentry *upperdentry, |
176 | struct ovl_entry *oe) | |
b07d5cc9 | 177 | { |
0af950f5 | 178 | return ovl_dentry_init_flags(dentry, upperdentry, oe, OVL_D_REVALIDATE); |
bbb1e54d MS |
179 | } |
180 | ||
b07d5cc9 | 181 | void ovl_dentry_init_flags(struct dentry *dentry, struct dentry *upperdentry, |
0af950f5 | 182 | struct ovl_entry *oe, unsigned int mask) |
f4288844 | 183 | { |
5522c9c7 | 184 | struct ovl_path *lowerstack = ovl_lowerstack(oe); |
f4288844 MS |
185 | unsigned int i, flags = 0; |
186 | ||
bccece1e MS |
187 | if (upperdentry) |
188 | flags |= upperdentry->d_flags; | |
41665644 | 189 | for (i = 0; i < ovl_numlower(oe) && lowerstack[i].dentry; i++) |
5522c9c7 | 190 | flags |= lowerstack[i].dentry->d_flags; |
f4288844 MS |
191 | |
192 | spin_lock(&dentry->d_lock); | |
193 | dentry->d_flags &= ~mask; | |
194 | dentry->d_flags |= flags & mask; | |
195 | spin_unlock(&dentry->d_lock); | |
196 | } | |
197 | ||
bbb1e54d MS |
198 | bool ovl_dentry_weird(struct dentry *dentry) |
199 | { | |
200 | return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT | | |
201 | DCACHE_MANAGE_TRANSIT | | |
202 | DCACHE_OP_HASH | | |
203 | DCACHE_OP_COMPARE); | |
204 | } | |
205 | ||
206 | enum ovl_path_type ovl_path_type(struct dentry *dentry) | |
207 | { | |
a6ff2bc0 | 208 | struct ovl_entry *oe = OVL_E(dentry); |
bbb1e54d MS |
209 | enum ovl_path_type type = 0; |
210 | ||
09d8b586 | 211 | if (ovl_dentry_upper(dentry)) { |
bbb1e54d MS |
212 | type = __OVL_PATH_UPPER; |
213 | ||
214 | /* | |
59548503 | 215 | * Non-dir dentry can hold lower dentry of its copy up origin. |
bbb1e54d | 216 | */ |
5522c9c7 | 217 | if (ovl_numlower(oe)) { |
60124877 VG |
218 | if (ovl_test_flag(OVL_CONST_INO, d_inode(dentry))) |
219 | type |= __OVL_PATH_ORIGIN; | |
0b17c28a VG |
220 | if (d_is_dir(dentry) || |
221 | !ovl_has_upperdata(d_inode(dentry))) | |
59548503 AG |
222 | type |= __OVL_PATH_MERGE; |
223 | } | |
bbb1e54d | 224 | } else { |
5522c9c7 | 225 | if (ovl_numlower(oe) > 1) |
bbb1e54d MS |
226 | type |= __OVL_PATH_MERGE; |
227 | } | |
228 | return type; | |
229 | } | |
230 | ||
231 | void ovl_path_upper(struct dentry *dentry, struct path *path) | |
232 | { | |
f01d0889 | 233 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); |
bbb1e54d | 234 | |
08f4c7c8 | 235 | path->mnt = ovl_upper_mnt(ofs); |
09d8b586 | 236 | path->dentry = ovl_dentry_upper(dentry); |
bbb1e54d MS |
237 | } |
238 | ||
239 | void ovl_path_lower(struct dentry *dentry, struct path *path) | |
240 | { | |
a6ff2bc0 | 241 | struct ovl_entry *oe = OVL_E(dentry); |
5522c9c7 | 242 | struct ovl_path *lowerpath = ovl_lowerstack(oe); |
bbb1e54d | 243 | |
5522c9c7 AG |
244 | if (ovl_numlower(oe)) { |
245 | path->mnt = lowerpath->layer->mnt; | |
246 | path->dentry = lowerpath->dentry; | |
b9343632 CR |
247 | } else { |
248 | *path = (struct path) { }; | |
249 | } | |
bbb1e54d MS |
250 | } |
251 | ||
4f93b426 VG |
252 | void ovl_path_lowerdata(struct dentry *dentry, struct path *path) |
253 | { | |
a6ff2bc0 | 254 | struct ovl_entry *oe = OVL_E(dentry); |
ab1eb5ff | 255 | struct ovl_path *lowerdata = ovl_lowerdata(oe); |
2b21da92 | 256 | struct dentry *lowerdata_dentry = ovl_lowerdata_dentry(oe); |
4f93b426 | 257 | |
2b21da92 | 258 | if (lowerdata_dentry) { |
2b21da92 | 259 | path->dentry = lowerdata_dentry; |
42dd69ae AG |
260 | /* |
261 | * Pairs with smp_wmb() in ovl_dentry_set_lowerdata(). | |
262 | * Make sure that if lowerdata->dentry is visible, then | |
263 | * datapath->layer is visible as well. | |
264 | */ | |
265 | smp_rmb(); | |
266 | path->mnt = READ_ONCE(lowerdata->layer)->mnt; | |
4f93b426 VG |
267 | } else { |
268 | *path = (struct path) { }; | |
269 | } | |
270 | } | |
271 | ||
bbb1e54d MS |
272 | enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) |
273 | { | |
274 | enum ovl_path_type type = ovl_path_type(dentry); | |
275 | ||
276 | if (!OVL_TYPE_UPPER(type)) | |
277 | ovl_path_lower(dentry, path); | |
278 | else | |
279 | ovl_path_upper(dentry, path); | |
280 | ||
281 | return type; | |
282 | } | |
283 | ||
1248ea4b AG |
284 | enum ovl_path_type ovl_path_realdata(struct dentry *dentry, struct path *path) |
285 | { | |
286 | enum ovl_path_type type = ovl_path_type(dentry); | |
287 | ||
288 | WARN_ON_ONCE(d_is_dir(dentry)); | |
289 | ||
290 | if (!OVL_TYPE_UPPER(type) || OVL_TYPE_MERGE(type)) | |
291 | ovl_path_lowerdata(dentry, path); | |
292 | else | |
293 | ovl_path_upper(dentry, path); | |
294 | ||
295 | return type; | |
296 | } | |
297 | ||
bbb1e54d MS |
298 | struct dentry *ovl_dentry_upper(struct dentry *dentry) |
299 | { | |
09d8b586 | 300 | return ovl_upperdentry_dereference(OVL_I(d_inode(dentry))); |
bbb1e54d MS |
301 | } |
302 | ||
303 | struct dentry *ovl_dentry_lower(struct dentry *dentry) | |
304 | { | |
a6ff2bc0 | 305 | struct ovl_entry *oe = OVL_E(dentry); |
bbb1e54d | 306 | |
5522c9c7 | 307 | return ovl_numlower(oe) ? ovl_lowerstack(oe)->dentry : NULL; |
bbb1e54d MS |
308 | } |
309 | ||
13464165 | 310 | const struct ovl_layer *ovl_layer_lower(struct dentry *dentry) |
da309e8c | 311 | { |
a6ff2bc0 | 312 | struct ovl_entry *oe = OVL_E(dentry); |
da309e8c | 313 | |
5522c9c7 | 314 | return ovl_numlower(oe) ? ovl_lowerstack(oe)->layer : NULL; |
da309e8c AG |
315 | } |
316 | ||
647d253f VG |
317 | /* |
318 | * ovl_dentry_lower() could return either a data dentry or metacopy dentry | |
597534e7 | 319 | * depending on what is stored in lowerstack[0]. At times we need to find |
647d253f VG |
320 | * lower dentry which has data (and not metacopy dentry). This helper |
321 | * returns the lower data dentry. | |
322 | */ | |
323 | struct dentry *ovl_dentry_lowerdata(struct dentry *dentry) | |
324 | { | |
ab1eb5ff | 325 | return ovl_lowerdata_dentry(OVL_E(dentry)); |
647d253f VG |
326 | } |
327 | ||
42dd69ae AG |
328 | int ovl_dentry_set_lowerdata(struct dentry *dentry, struct ovl_path *datapath) |
329 | { | |
330 | struct ovl_entry *oe = OVL_E(dentry); | |
331 | struct ovl_path *lowerdata = ovl_lowerdata(oe); | |
332 | struct dentry *datadentry = datapath->dentry; | |
333 | ||
334 | if (WARN_ON_ONCE(ovl_numlower(oe) <= 1)) | |
335 | return -EIO; | |
336 | ||
337 | WRITE_ONCE(lowerdata->layer, datapath->layer); | |
338 | /* | |
339 | * Pairs with smp_rmb() in ovl_path_lowerdata(). | |
340 | * Make sure that if lowerdata->dentry is visible, then | |
341 | * lowerdata->layer is visible as well. | |
342 | */ | |
343 | smp_wmb(); | |
344 | WRITE_ONCE(lowerdata->dentry, dget(datadentry)); | |
345 | ||
346 | ovl_dentry_update_reval(dentry, datadentry); | |
347 | ||
348 | return 0; | |
349 | } | |
350 | ||
bbb1e54d MS |
351 | struct dentry *ovl_dentry_real(struct dentry *dentry) |
352 | { | |
09d8b586 | 353 | return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry); |
bbb1e54d MS |
354 | } |
355 | ||
1d88f183 MS |
356 | struct dentry *ovl_i_dentry_upper(struct inode *inode) |
357 | { | |
358 | return ovl_upperdentry_dereference(OVL_I(inode)); | |
359 | } | |
360 | ||
b2dd05f1 | 361 | struct inode *ovl_i_path_real(struct inode *inode, struct path *path) |
ffa5723c | 362 | { |
ac900ed4 AG |
363 | struct ovl_path *lowerpath = ovl_lowerpath(OVL_I_E(inode)); |
364 | ||
ffa5723c AG |
365 | path->dentry = ovl_i_dentry_upper(inode); |
366 | if (!path->dentry) { | |
ac900ed4 AG |
367 | path->dentry = lowerpath->dentry; |
368 | path->mnt = lowerpath->layer->mnt; | |
ffa5723c AG |
369 | } else { |
370 | path->mnt = ovl_upper_mnt(OVL_FS(inode->i_sb)); | |
371 | } | |
b2dd05f1 ZC |
372 | |
373 | return path->dentry ? d_inode_rcu(path->dentry) : NULL; | |
ffa5723c AG |
374 | } |
375 | ||
09d8b586 | 376 | struct inode *ovl_inode_upper(struct inode *inode) |
25b7713a | 377 | { |
1d88f183 | 378 | struct dentry *upperdentry = ovl_i_dentry_upper(inode); |
25b7713a | 379 | |
09d8b586 MS |
380 | return upperdentry ? d_inode(upperdentry) : NULL; |
381 | } | |
25b7713a | 382 | |
09d8b586 MS |
383 | struct inode *ovl_inode_lower(struct inode *inode) |
384 | { | |
ac900ed4 | 385 | struct ovl_path *lowerpath = ovl_lowerpath(OVL_I_E(inode)); |
ffa5723c | 386 | |
ac900ed4 | 387 | return lowerpath ? d_inode(lowerpath->dentry) : NULL; |
09d8b586 | 388 | } |
25b7713a | 389 | |
09d8b586 MS |
390 | struct inode *ovl_inode_real(struct inode *inode) |
391 | { | |
392 | return ovl_inode_upper(inode) ?: ovl_inode_lower(inode); | |
25b7713a MS |
393 | } |
394 | ||
2664bd08 VG |
395 | /* Return inode which contains lower data. Do not return metacopy */ |
396 | struct inode *ovl_inode_lowerdata(struct inode *inode) | |
397 | { | |
ab1eb5ff AG |
398 | struct dentry *lowerdata = ovl_lowerdata_dentry(OVL_I_E(inode)); |
399 | ||
2664bd08 VG |
400 | if (WARN_ON(!S_ISREG(inode->i_mode))) |
401 | return NULL; | |
402 | ||
ab1eb5ff | 403 | return lowerdata ? d_inode(lowerdata) : NULL; |
2664bd08 | 404 | } |
09d8b586 | 405 | |
4823d49c VG |
406 | /* Return real inode which contains data. Does not return metacopy inode */ |
407 | struct inode *ovl_inode_realdata(struct inode *inode) | |
408 | { | |
409 | struct inode *upperinode; | |
410 | ||
411 | upperinode = ovl_inode_upper(inode); | |
412 | if (upperinode && ovl_has_upperdata(inode)) | |
413 | return upperinode; | |
414 | ||
415 | return ovl_inode_lowerdata(inode); | |
416 | } | |
417 | ||
2b21da92 AG |
418 | const char *ovl_lowerdata_redirect(struct inode *inode) |
419 | { | |
420 | return inode && S_ISREG(inode->i_mode) ? | |
421 | OVL_I(inode)->lowerdata_redirect : NULL; | |
422 | } | |
423 | ||
4edb83bb | 424 | struct ovl_dir_cache *ovl_dir_cache(struct inode *inode) |
bbb1e54d | 425 | { |
2b21da92 | 426 | return inode && S_ISDIR(inode->i_mode) ? OVL_I(inode)->cache : NULL; |
bbb1e54d MS |
427 | } |
428 | ||
4edb83bb | 429 | void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache) |
bbb1e54d | 430 | { |
4edb83bb | 431 | OVL_I(inode)->cache = cache; |
bbb1e54d MS |
432 | } |
433 | ||
c62520a8 AG |
434 | void ovl_dentry_set_flag(unsigned long flag, struct dentry *dentry) |
435 | { | |
a6ff2bc0 | 436 | set_bit(flag, OVL_E_FLAGS(dentry)); |
c62520a8 AG |
437 | } |
438 | ||
439 | void ovl_dentry_clear_flag(unsigned long flag, struct dentry *dentry) | |
440 | { | |
a6ff2bc0 | 441 | clear_bit(flag, OVL_E_FLAGS(dentry)); |
c62520a8 AG |
442 | } |
443 | ||
444 | bool ovl_dentry_test_flag(unsigned long flag, struct dentry *dentry) | |
445 | { | |
a6ff2bc0 | 446 | return test_bit(flag, OVL_E_FLAGS(dentry)); |
c62520a8 AG |
447 | } |
448 | ||
bbb1e54d MS |
449 | bool ovl_dentry_is_opaque(struct dentry *dentry) |
450 | { | |
c62520a8 | 451 | return ovl_dentry_test_flag(OVL_E_OPAQUE, dentry); |
bbb1e54d MS |
452 | } |
453 | ||
454 | bool ovl_dentry_is_whiteout(struct dentry *dentry) | |
455 | { | |
456 | return !dentry->d_inode && ovl_dentry_is_opaque(dentry); | |
457 | } | |
458 | ||
5cf5b477 | 459 | void ovl_dentry_set_opaque(struct dentry *dentry) |
bbb1e54d | 460 | { |
c62520a8 | 461 | ovl_dentry_set_flag(OVL_E_OPAQUE, dentry); |
bbb1e54d MS |
462 | } |
463 | ||
420332b9 AG |
464 | bool ovl_dentry_has_xwhiteouts(struct dentry *dentry) |
465 | { | |
466 | return ovl_dentry_test_flag(OVL_E_XWHITEOUTS, dentry); | |
467 | } | |
468 | ||
469 | void ovl_dentry_set_xwhiteouts(struct dentry *dentry) | |
470 | { | |
471 | ovl_dentry_set_flag(OVL_E_XWHITEOUTS, dentry); | |
472 | } | |
473 | ||
474 | /* | |
475 | * ovl_layer_set_xwhiteouts() is called before adding the overlay dir | |
476 | * dentry to dcache, while readdir of that same directory happens after | |
477 | * the overlay dir dentry is in dcache, so if some cpu observes that | |
478 | * ovl_dentry_is_xwhiteouts(), it will also observe layer->has_xwhiteouts | |
479 | * for the layers where xwhiteouts marker was found in that merge dir. | |
480 | */ | |
481 | void ovl_layer_set_xwhiteouts(struct ovl_fs *ofs, | |
482 | const struct ovl_layer *layer) | |
483 | { | |
484 | if (layer->has_xwhiteouts) | |
485 | return; | |
486 | ||
487 | /* Write once to read-mostly layer properties */ | |
488 | ofs->layers[layer->idx].has_xwhiteouts = true; | |
489 | } | |
490 | ||
55acc661 | 491 | /* |
aa3ff3c1 AG |
492 | * For hard links and decoded file handles, it's possible for ovl_dentry_upper() |
493 | * to return positive, while there's no actual upper alias for the inode. | |
494 | * Copy up code needs to know about the existence of the upper alias, so it | |
495 | * can't use ovl_dentry_upper(). | |
55acc661 MS |
496 | */ |
497 | bool ovl_dentry_has_upper_alias(struct dentry *dentry) | |
498 | { | |
c62520a8 | 499 | return ovl_dentry_test_flag(OVL_E_UPPER_ALIAS, dentry); |
55acc661 MS |
500 | } |
501 | ||
502 | void ovl_dentry_set_upper_alias(struct dentry *dentry) | |
503 | { | |
c62520a8 | 504 | ovl_dentry_set_flag(OVL_E_UPPER_ALIAS, dentry); |
55acc661 MS |
505 | } |
506 | ||
0c288874 VG |
507 | static bool ovl_should_check_upperdata(struct inode *inode) |
508 | { | |
509 | if (!S_ISREG(inode->i_mode)) | |
510 | return false; | |
511 | ||
512 | if (!ovl_inode_lower(inode)) | |
513 | return false; | |
514 | ||
515 | return true; | |
516 | } | |
517 | ||
518 | bool ovl_has_upperdata(struct inode *inode) | |
519 | { | |
520 | if (!ovl_should_check_upperdata(inode)) | |
521 | return true; | |
522 | ||
523 | if (!ovl_test_flag(OVL_UPPERDATA, inode)) | |
524 | return false; | |
525 | /* | |
526 | * Pairs with smp_wmb() in ovl_set_upperdata(). Main user of | |
527 | * ovl_has_upperdata() is ovl_copy_up_meta_inode_data(). Make sure | |
528 | * if setting of OVL_UPPERDATA is visible, then effects of writes | |
529 | * before that are visible too. | |
530 | */ | |
531 | smp_rmb(); | |
532 | return true; | |
533 | } | |
534 | ||
535 | void ovl_set_upperdata(struct inode *inode) | |
536 | { | |
537 | /* | |
538 | * Pairs with smp_rmb() in ovl_has_upperdata(). Make sure | |
539 | * if OVL_UPPERDATA flag is visible, then effects of write operations | |
540 | * before it are visible as well. | |
541 | */ | |
542 | smp_wmb(); | |
543 | ovl_set_flag(OVL_UPPERDATA, inode); | |
544 | } | |
545 | ||
546 | /* Caller should hold ovl_inode->lock */ | |
547 | bool ovl_dentry_needs_data_copy_up_locked(struct dentry *dentry, int flags) | |
548 | { | |
549 | if (!ovl_open_flags_need_copy_up(flags)) | |
550 | return false; | |
551 | ||
552 | return !ovl_test_flag(OVL_UPPERDATA, d_inode(dentry)); | |
553 | } | |
554 | ||
555 | bool ovl_dentry_needs_data_copy_up(struct dentry *dentry, int flags) | |
556 | { | |
557 | if (!ovl_open_flags_need_copy_up(flags)) | |
558 | return false; | |
559 | ||
560 | return !ovl_has_upperdata(d_inode(dentry)); | |
561 | } | |
562 | ||
a6c60655 MS |
563 | const char *ovl_dentry_get_redirect(struct dentry *dentry) |
564 | { | |
cf31c463 | 565 | return OVL_I(d_inode(dentry))->redirect; |
a6c60655 MS |
566 | } |
567 | ||
568 | void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect) | |
569 | { | |
cf31c463 | 570 | struct ovl_inode *oi = OVL_I(d_inode(dentry)); |
a6c60655 | 571 | |
cf31c463 MS |
572 | kfree(oi->redirect); |
573 | oi->redirect = redirect; | |
a6c60655 MS |
574 | } |
575 | ||
09d8b586 | 576 | void ovl_inode_update(struct inode *inode, struct dentry *upperdentry) |
bbb1e54d | 577 | { |
09d8b586 | 578 | struct inode *upperinode = d_inode(upperdentry); |
e6d2ebdd | 579 | |
09d8b586 MS |
580 | WARN_ON(OVL_I(inode)->__upperdentry); |
581 | ||
25b7713a | 582 | /* |
09d8b586 | 583 | * Make sure upperdentry is consistent before making it visible |
25b7713a MS |
584 | */ |
585 | smp_wmb(); | |
09d8b586 | 586 | OVL_I(inode)->__upperdentry = upperdentry; |
31747eda | 587 | if (inode_unhashed(inode)) { |
25b7713a | 588 | inode->i_private = upperinode; |
bbb1e54d | 589 | __insert_inode_hash(inode, (unsigned long) upperinode); |
25b7713a | 590 | } |
bbb1e54d MS |
591 | } |
592 | ||
65cd913e | 593 | static void ovl_dir_version_inc(struct dentry *dentry, bool impurity) |
bbb1e54d | 594 | { |
04a01ac7 | 595 | struct inode *inode = d_inode(dentry); |
bbb1e54d | 596 | |
04a01ac7 | 597 | WARN_ON(!inode_is_locked(inode)); |
65cd913e | 598 | WARN_ON(!d_is_dir(dentry)); |
4edb83bb | 599 | /* |
65cd913e AG |
600 | * Version is used by readdir code to keep cache consistent. |
601 | * For merge dirs (or dirs with origin) all changes need to be noted. | |
602 | * For non-merge dirs, cache contains only impure entries (i.e. ones | |
603 | * which have been copied up and have origins), so only need to note | |
604 | * changes to impure entries. | |
4edb83bb | 605 | */ |
1fa9c5c5 | 606 | if (!ovl_dir_is_real(inode) || impurity) |
4edb83bb | 607 | OVL_I(inode)->version++; |
bbb1e54d MS |
608 | } |
609 | ||
d9854c87 MS |
610 | void ovl_dir_modified(struct dentry *dentry, bool impurity) |
611 | { | |
612 | /* Copy mtime/ctime */ | |
2878dffc | 613 | ovl_copyattr(d_inode(dentry)); |
d9854c87 | 614 | |
65cd913e | 615 | ovl_dir_version_inc(dentry, impurity); |
d9854c87 MS |
616 | } |
617 | ||
1fa9c5c5 | 618 | u64 ovl_inode_version_get(struct inode *inode) |
bbb1e54d | 619 | { |
04a01ac7 MS |
620 | WARN_ON(!inode_is_locked(inode)); |
621 | return OVL_I(inode)->version; | |
bbb1e54d MS |
622 | } |
623 | ||
624 | bool ovl_is_whiteout(struct dentry *dentry) | |
625 | { | |
626 | struct inode *inode = dentry->d_inode; | |
627 | ||
628 | return inode && IS_WHITEOUT(inode); | |
629 | } | |
630 | ||
bc8df7a3 AL |
631 | /* |
632 | * Use this over ovl_is_whiteout for upper and lower files, as it also | |
633 | * handles overlay.whiteout xattr whiteout files. | |
634 | */ | |
635 | bool ovl_path_is_whiteout(struct ovl_fs *ofs, const struct path *path) | |
636 | { | |
637 | return ovl_is_whiteout(path->dentry) || | |
638 | ovl_path_check_xwhiteout_xattr(ofs, path); | |
639 | } | |
640 | ||
2d343087 | 641 | struct file *ovl_path_open(const struct path *path, int flags) |
bbb1e54d | 642 | { |
56230d95 | 643 | struct inode *inode = d_inode(path->dentry); |
4609e1f1 | 644 | struct mnt_idmap *real_idmap = mnt_idmap(path->mnt); |
56230d95 MS |
645 | int err, acc_mode; |
646 | ||
647 | if (flags & ~(O_ACCMODE | O_LARGEFILE)) | |
648 | BUG(); | |
649 | ||
650 | switch (flags & O_ACCMODE) { | |
651 | case O_RDONLY: | |
652 | acc_mode = MAY_READ; | |
653 | break; | |
654 | case O_WRONLY: | |
655 | acc_mode = MAY_WRITE; | |
656 | break; | |
657 | default: | |
658 | BUG(); | |
659 | } | |
660 | ||
4609e1f1 | 661 | err = inode_permission(real_idmap, inode, acc_mode | MAY_OPEN); |
56230d95 MS |
662 | if (err) |
663 | return ERR_PTR(err); | |
664 | ||
665 | /* O_NOATIME is an optimization, don't fail if not permitted */ | |
01beba79 | 666 | if (inode_owner_or_capable(real_idmap, inode)) |
56230d95 MS |
667 | flags |= O_NOATIME; |
668 | ||
669 | return dentry_open(path, flags, current_cred()); | |
bbb1e54d | 670 | } |
39d3d60a | 671 | |
0c288874 VG |
672 | /* Caller should hold ovl_inode->lock */ |
673 | static bool ovl_already_copied_up_locked(struct dentry *dentry, int flags) | |
674 | { | |
675 | bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED; | |
676 | ||
677 | if (ovl_dentry_upper(dentry) && | |
678 | (ovl_dentry_has_upper_alias(dentry) || disconnected) && | |
679 | !ovl_dentry_needs_data_copy_up_locked(dentry, flags)) | |
680 | return true; | |
681 | ||
682 | return false; | |
683 | } | |
684 | ||
685 | bool ovl_already_copied_up(struct dentry *dentry, int flags) | |
2002df85 VG |
686 | { |
687 | bool disconnected = dentry->d_flags & DCACHE_DISCONNECTED; | |
688 | ||
689 | /* | |
690 | * Check if copy-up has happened as well as for upper alias (in | |
691 | * case of hard links) is there. | |
692 | * | |
693 | * Both checks are lockless: | |
694 | * - false negatives: will recheck under oi->lock | |
695 | * - false positives: | |
696 | * + ovl_dentry_upper() uses memory barriers to ensure the | |
697 | * upper dentry is up-to-date | |
698 | * + ovl_dentry_has_upper_alias() relies on locking of | |
699 | * upper parent i_rwsem to prevent reordering copy-up | |
700 | * with rename. | |
701 | */ | |
702 | if (ovl_dentry_upper(dentry) && | |
0c288874 VG |
703 | (ovl_dentry_has_upper_alias(dentry) || disconnected) && |
704 | !ovl_dentry_needs_data_copy_up(dentry, flags)) | |
2002df85 VG |
705 | return true; |
706 | ||
707 | return false; | |
708 | } | |
709 | ||
c63e56a4 AG |
710 | /* |
711 | * The copy up "transaction" keeps an elevated mnt write count on upper mnt, | |
712 | * but leaves taking freeze protection on upper sb to lower level helpers. | |
713 | */ | |
0c288874 | 714 | int ovl_copy_up_start(struct dentry *dentry, int flags) |
39d3d60a | 715 | { |
1e92e307 | 716 | struct inode *inode = d_inode(dentry); |
39d3d60a AG |
717 | int err; |
718 | ||
531d3040 | 719 | err = ovl_inode_lock_interruptible(inode); |
162d0644 AG |
720 | if (err) |
721 | return err; | |
722 | ||
723 | if (ovl_already_copied_up_locked(dentry, flags)) | |
a015dafc | 724 | err = 1; /* Already copied up */ |
162d0644 | 725 | else |
c63e56a4 | 726 | err = ovl_get_write_access(dentry); |
162d0644 AG |
727 | if (err) |
728 | goto out_unlock; | |
729 | ||
730 | return 0; | |
39d3d60a | 731 | |
162d0644 AG |
732 | out_unlock: |
733 | ovl_inode_unlock(inode); | |
39d3d60a AG |
734 | return err; |
735 | } | |
736 | ||
737 | void ovl_copy_up_end(struct dentry *dentry) | |
738 | { | |
c63e56a4 | 739 | ovl_put_write_access(dentry); |
1e92e307 | 740 | ovl_inode_unlock(d_inode(dentry)); |
39d3d60a | 741 | } |
82b749b2 | 742 | |
2d343087 | 743 | bool ovl_path_check_origin_xattr(struct ovl_fs *ofs, const struct path *path) |
b79e05aa AG |
744 | { |
745 | int res; | |
746 | ||
dad7017a | 747 | res = ovl_path_getxattr(ofs, path, OVL_XATTR_ORIGIN, NULL, 0); |
b79e05aa AG |
748 | |
749 | /* Zero size value means "copied up but origin unknown" */ | |
750 | if (res >= 0) | |
751 | return true; | |
752 | ||
753 | return false; | |
754 | } | |
755 | ||
bc8df7a3 AL |
756 | bool ovl_path_check_xwhiteout_xattr(struct ovl_fs *ofs, const struct path *path) |
757 | { | |
758 | struct dentry *dentry = path->dentry; | |
759 | int res; | |
760 | ||
761 | /* xattr.whiteout must be a zero size regular file */ | |
762 | if (!d_is_reg(dentry) || i_size_read(d_inode(dentry)) != 0) | |
763 | return false; | |
764 | ||
765 | res = ovl_path_getxattr(ofs, path, OVL_XATTR_XWHITEOUT, NULL, 0); | |
766 | return res >= 0; | |
767 | } | |
768 | ||
d9544c1b AG |
769 | /* |
770 | * Load persistent uuid from xattr into s_uuid if found, or store a new | |
771 | * random generated value in s_uuid and in xattr. | |
772 | */ | |
773 | bool ovl_init_uuid_xattr(struct super_block *sb, struct ovl_fs *ofs, | |
774 | const struct path *upperpath) | |
775 | { | |
776 | bool set = false; | |
dd901960 | 777 | uuid_t uuid; |
d9544c1b AG |
778 | int res; |
779 | ||
780 | /* Try to load existing persistent uuid */ | |
dd901960 | 781 | res = ovl_path_getxattr(ofs, upperpath, OVL_XATTR_UUID, uuid.b, |
d9544c1b AG |
782 | UUID_SIZE); |
783 | if (res == UUID_SIZE) | |
dd901960 | 784 | goto set_uuid; |
d9544c1b AG |
785 | |
786 | if (res != -ENODATA) | |
787 | goto fail; | |
788 | ||
cbb44f09 AG |
789 | /* |
790 | * With uuid=auto, if uuid xattr is found, it will be used. | |
791 | * If uuid xattrs is not found, generate a persistent uuid only on mount | |
792 | * of new overlays where upper root dir is not yet marked as impure. | |
793 | * An upper dir is marked as impure on copy up or lookup of its subdirs. | |
794 | */ | |
795 | if (ofs->config.uuid == OVL_UUID_AUTO) { | |
796 | res = ovl_path_getxattr(ofs, upperpath, OVL_XATTR_IMPURE, NULL, | |
797 | 0); | |
798 | if (res > 0) { | |
799 | /* Any mount of old overlay - downgrade to uuid=null */ | |
800 | ofs->config.uuid = OVL_UUID_NULL; | |
801 | return true; | |
802 | } else if (res == -ENODATA) { | |
803 | /* First mount of new overlay - upgrade to uuid=on */ | |
804 | ofs->config.uuid = OVL_UUID_ON; | |
805 | } else if (res < 0) { | |
806 | goto fail; | |
807 | } | |
808 | ||
809 | } | |
810 | ||
d9544c1b | 811 | /* Generate overlay instance uuid */ |
dd901960 | 812 | uuid_gen(&uuid); |
d9544c1b AG |
813 | |
814 | /* Try to store persistent uuid */ | |
815 | set = true; | |
dd901960 | 816 | res = ovl_setxattr(ofs, upperpath->dentry, OVL_XATTR_UUID, uuid.b, |
d9544c1b | 817 | UUID_SIZE); |
dd901960 KO |
818 | if (res) |
819 | goto fail; | |
820 | ||
821 | set_uuid: | |
822 | super_set_uuid(sb, uuid.b, sizeof(uuid)); | |
823 | return true; | |
d9544c1b AG |
824 | |
825 | fail: | |
d9544c1b AG |
826 | ofs->config.uuid = OVL_UUID_NULL; |
827 | pr_warn("failed to %s uuid (%pd2, err=%i); falling back to uuid=null.\n", | |
828 | set ? "set" : "get", upperpath->dentry, res); | |
829 | return false; | |
830 | } | |
831 | ||
420332b9 AG |
832 | char ovl_get_dir_xattr_val(struct ovl_fs *ofs, const struct path *path, |
833 | enum ovl_xattr ox) | |
f3a15685 AG |
834 | { |
835 | int res; | |
836 | char val; | |
837 | ||
dad7017a | 838 | if (!d_is_dir(path->dentry)) |
420332b9 | 839 | return 0; |
f3a15685 | 840 | |
dad7017a | 841 | res = ovl_path_getxattr(ofs, path, ox, &val, 1); |
420332b9 | 842 | return res == 1 ? val : 0; |
f3a15685 AG |
843 | } |
844 | ||
43d193f8 MS |
845 | #define OVL_XATTR_OPAQUE_POSTFIX "opaque" |
846 | #define OVL_XATTR_REDIRECT_POSTFIX "redirect" | |
847 | #define OVL_XATTR_ORIGIN_POSTFIX "origin" | |
848 | #define OVL_XATTR_IMPURE_POSTFIX "impure" | |
849 | #define OVL_XATTR_NLINK_POSTFIX "nlink" | |
850 | #define OVL_XATTR_UPPER_POSTFIX "upper" | |
d9544c1b | 851 | #define OVL_XATTR_UUID_POSTFIX "uuid" |
43d193f8 | 852 | #define OVL_XATTR_METACOPY_POSTFIX "metacopy" |
096a218a | 853 | #define OVL_XATTR_PROTATTR_POSTFIX "protattr" |
bc8df7a3 | 854 | #define OVL_XATTR_XWHITEOUT_POSTFIX "whiteout" |
43d193f8 MS |
855 | |
856 | #define OVL_XATTR_TAB_ENTRY(x) \ | |
2d2f2d73 MS |
857 | [x] = { [false] = OVL_XATTR_TRUSTED_PREFIX x ## _POSTFIX, \ |
858 | [true] = OVL_XATTR_USER_PREFIX x ## _POSTFIX } | |
43d193f8 | 859 | |
2d2f2d73 | 860 | const char *const ovl_xattr_table[][2] = { |
43d193f8 MS |
861 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_OPAQUE), |
862 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_REDIRECT), | |
863 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_ORIGIN), | |
864 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_IMPURE), | |
865 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_NLINK), | |
866 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_UPPER), | |
d9544c1b | 867 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_UUID), |
43d193f8 | 868 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_METACOPY), |
096a218a | 869 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_PROTATTR), |
bc8df7a3 | 870 | OVL_XATTR_TAB_ENTRY(OVL_XATTR_XWHITEOUT), |
43d193f8 MS |
871 | }; |
872 | ||
a0c236b1 | 873 | int ovl_check_setxattr(struct ovl_fs *ofs, struct dentry *upperdentry, |
43d193f8 | 874 | enum ovl_xattr ox, const void *value, size_t size, |
82b749b2 AG |
875 | int xerr) |
876 | { | |
877 | int err; | |
82b749b2 AG |
878 | |
879 | if (ofs->noxattr) | |
880 | return xerr; | |
881 | ||
c914c0e2 | 882 | err = ovl_setxattr(ofs, upperdentry, ox, value, size); |
82b749b2 AG |
883 | |
884 | if (err == -EOPNOTSUPP) { | |
43d193f8 | 885 | pr_warn("cannot set %s xattr on upper\n", ovl_xattr(ofs, ox)); |
82b749b2 AG |
886 | ofs->noxattr = true; |
887 | return xerr; | |
888 | } | |
889 | ||
890 | return err; | |
891 | } | |
f3a15685 AG |
892 | |
893 | int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry) | |
894 | { | |
a0c236b1 | 895 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); |
f3a15685 | 896 | int err; |
f3a15685 | 897 | |
13c72075 | 898 | if (ovl_test_flag(OVL_IMPURE, d_inode(dentry))) |
f3a15685 AG |
899 | return 0; |
900 | ||
901 | /* | |
902 | * Do not fail when upper doesn't support xattrs. | |
903 | * Upper inodes won't have origin nor redirect xattr anyway. | |
904 | */ | |
a0c236b1 | 905 | err = ovl_check_setxattr(ofs, upperdentry, OVL_XATTR_IMPURE, "y", 1, 0); |
f3a15685 | 906 | if (!err) |
13c72075 | 907 | ovl_set_flag(OVL_IMPURE, d_inode(dentry)); |
f3a15685 AG |
908 | |
909 | return err; | |
910 | } | |
13c72075 | 911 | |
096a218a AG |
912 | |
913 | #define OVL_PROTATTR_MAX 32 /* Reserved for future flags */ | |
914 | ||
915 | void ovl_check_protattr(struct inode *inode, struct dentry *upper) | |
916 | { | |
917 | struct ovl_fs *ofs = OVL_FS(inode->i_sb); | |
918 | u32 iflags = inode->i_flags & OVL_PROT_I_FLAGS_MASK; | |
919 | char buf[OVL_PROTATTR_MAX+1]; | |
920 | int res, n; | |
921 | ||
dad7017a CB |
922 | res = ovl_getxattr_upper(ofs, upper, OVL_XATTR_PROTATTR, buf, |
923 | OVL_PROTATTR_MAX); | |
096a218a AG |
924 | if (res < 0) |
925 | return; | |
926 | ||
927 | /* | |
928 | * Initialize inode flags from overlay.protattr xattr and upper inode | |
929 | * flags. If upper inode has those fileattr flags set (i.e. from old | |
930 | * kernel), we do not clear them on ovl_get_inode(), but we will clear | |
931 | * them on next fileattr_set(). | |
932 | */ | |
933 | for (n = 0; n < res; n++) { | |
934 | if (buf[n] == 'a') | |
935 | iflags |= S_APPEND; | |
936 | else if (buf[n] == 'i') | |
937 | iflags |= S_IMMUTABLE; | |
938 | else | |
939 | break; | |
940 | } | |
941 | ||
942 | if (!res || n < res) { | |
943 | pr_warn_ratelimited("incompatible overlay.protattr format (%pd2, len=%d)\n", | |
944 | upper, res); | |
945 | } else { | |
946 | inode_set_flags(inode, iflags, OVL_PROT_I_FLAGS_MASK); | |
947 | } | |
948 | } | |
949 | ||
950 | int ovl_set_protattr(struct inode *inode, struct dentry *upper, | |
951 | struct fileattr *fa) | |
952 | { | |
953 | struct ovl_fs *ofs = OVL_FS(inode->i_sb); | |
954 | char buf[OVL_PROTATTR_MAX]; | |
955 | int len = 0, err = 0; | |
956 | u32 iflags = 0; | |
957 | ||
958 | BUILD_BUG_ON(HWEIGHT32(OVL_PROT_FS_FLAGS_MASK) > OVL_PROTATTR_MAX); | |
959 | ||
960 | if (fa->flags & FS_APPEND_FL) { | |
961 | buf[len++] = 'a'; | |
962 | iflags |= S_APPEND; | |
963 | } | |
964 | if (fa->flags & FS_IMMUTABLE_FL) { | |
965 | buf[len++] = 'i'; | |
966 | iflags |= S_IMMUTABLE; | |
967 | } | |
968 | ||
969 | /* | |
970 | * Do not allow to set protection flags when upper doesn't support | |
971 | * xattrs, because we do not set those fileattr flags on upper inode. | |
972 | * Remove xattr if it exist and all protection flags are cleared. | |
973 | */ | |
974 | if (len) { | |
975 | err = ovl_check_setxattr(ofs, upper, OVL_XATTR_PROTATTR, | |
976 | buf, len, -EPERM); | |
977 | } else if (inode->i_flags & OVL_PROT_I_FLAGS_MASK) { | |
c914c0e2 | 978 | err = ovl_removexattr(ofs, upper, OVL_XATTR_PROTATTR); |
096a218a AG |
979 | if (err == -EOPNOTSUPP || err == -ENODATA) |
980 | err = 0; | |
981 | } | |
982 | if (err) | |
983 | return err; | |
984 | ||
985 | inode_set_flags(inode, iflags, OVL_PROT_I_FLAGS_MASK); | |
986 | ||
987 | /* Mask out the fileattr flags that should not be set in upper inode */ | |
988 | fa->flags &= ~OVL_PROT_FS_FLAGS_MASK; | |
989 | fa->fsx_xflags &= ~OVL_PROT_FSX_FLAGS_MASK; | |
990 | ||
991 | return 0; | |
992 | } | |
993 | ||
b28060db | 994 | /* |
ad0af710 AG |
995 | * Caller must hold a reference to inode to prevent it from being freed while |
996 | * it is marked inuse. | |
997 | */ | |
998 | bool ovl_inuse_trylock(struct dentry *dentry) | |
999 | { | |
1000 | struct inode *inode = d_inode(dentry); | |
1001 | bool locked = false; | |
1002 | ||
1003 | spin_lock(&inode->i_lock); | |
1004 | if (!(inode->i_state & I_OVL_INUSE)) { | |
1005 | inode->i_state |= I_OVL_INUSE; | |
1006 | locked = true; | |
1007 | } | |
1008 | spin_unlock(&inode->i_lock); | |
1009 | ||
1010 | return locked; | |
1011 | } | |
1012 | ||
1013 | void ovl_inuse_unlock(struct dentry *dentry) | |
1014 | { | |
1015 | if (dentry) { | |
1016 | struct inode *inode = d_inode(dentry); | |
1017 | ||
1018 | spin_lock(&inode->i_lock); | |
1019 | WARN_ON(!(inode->i_state & I_OVL_INUSE)); | |
1020 | inode->i_state &= ~I_OVL_INUSE; | |
1021 | spin_unlock(&inode->i_lock); | |
1022 | } | |
1023 | } | |
5f8415d6 | 1024 | |
146d62e5 AG |
1025 | bool ovl_is_inuse(struct dentry *dentry) |
1026 | { | |
1027 | struct inode *inode = d_inode(dentry); | |
1028 | bool inuse; | |
1029 | ||
1030 | spin_lock(&inode->i_lock); | |
1031 | inuse = (inode->i_state & I_OVL_INUSE); | |
1032 | spin_unlock(&inode->i_lock); | |
1033 | ||
1034 | return inuse; | |
1035 | } | |
1036 | ||
24b33ee1 AG |
1037 | /* |
1038 | * Does this overlay dentry need to be indexed on copy up? | |
1039 | */ | |
1040 | bool ovl_need_index(struct dentry *dentry) | |
1041 | { | |
1042 | struct dentry *lower = ovl_dentry_lower(dentry); | |
1043 | ||
1044 | if (!lower || !ovl_indexdir(dentry->d_sb)) | |
1045 | return false; | |
1046 | ||
fbd2d207 | 1047 | /* Index all files for NFS export and consistency verification */ |
016b720f | 1048 | if (ovl_index_all(dentry->d_sb)) |
fbd2d207 AG |
1049 | return true; |
1050 | ||
24b33ee1 AG |
1051 | /* Index only lower hardlinks on copy up */ |
1052 | if (!d_is_dir(lower) && d_inode(lower)->i_nlink > 1) | |
1053 | return true; | |
1054 | ||
1055 | return false; | |
1056 | } | |
1057 | ||
9f4ec904 | 1058 | /* Caller must hold OVL_I(inode)->lock */ |
caf70cb2 AG |
1059 | static void ovl_cleanup_index(struct dentry *dentry) |
1060 | { | |
1cdb0cb6 | 1061 | struct ovl_fs *ofs = OVL_FS(dentry->d_sb); |
e7dd0e71 AG |
1062 | struct dentry *indexdir = ovl_indexdir(dentry->d_sb); |
1063 | struct inode *dir = indexdir->d_inode; | |
caf70cb2 AG |
1064 | struct dentry *lowerdentry = ovl_dentry_lower(dentry); |
1065 | struct dentry *upperdentry = ovl_dentry_upper(dentry); | |
1066 | struct dentry *index = NULL; | |
1067 | struct inode *inode; | |
63e13252 | 1068 | struct qstr name = { }; |
5b02bfc1 | 1069 | bool got_write = false; |
caf70cb2 AG |
1070 | int err; |
1071 | ||
1cdb0cb6 | 1072 | err = ovl_get_index_name(ofs, lowerdentry, &name); |
caf70cb2 AG |
1073 | if (err) |
1074 | goto fail; | |
1075 | ||
5b02bfc1 AG |
1076 | err = ovl_want_write(dentry); |
1077 | if (err) | |
1078 | goto fail; | |
1079 | ||
1080 | got_write = true; | |
caf70cb2 | 1081 | inode = d_inode(upperdentry); |
89a17556 | 1082 | if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) { |
1bd0a3ae | 1083 | pr_warn_ratelimited("cleanup linked index (%pd2, ino=%lu, nlink=%u)\n", |
caf70cb2 AG |
1084 | upperdentry, inode->i_ino, inode->i_nlink); |
1085 | /* | |
1086 | * We either have a bug with persistent union nlink or a lower | |
1087 | * hardlink was added while overlay is mounted. Adding a lower | |
1088 | * hardlink and then unlinking all overlay hardlinks would drop | |
1089 | * overlay nlink to zero before all upper inodes are unlinked. | |
1090 | * As a safety measure, when that situation is detected, set | |
1091 | * the overlay nlink to the index inode nlink minus one for the | |
1092 | * index entry itself. | |
1093 | */ | |
1094 | set_nlink(d_inode(dentry), inode->i_nlink - 1); | |
1095 | ovl_set_nlink_upper(dentry); | |
1096 | goto out; | |
1097 | } | |
1098 | ||
1099 | inode_lock_nested(dir, I_MUTEX_PARENT); | |
22f289ce | 1100 | index = ovl_lookup_upper(ofs, name.name, indexdir, name.len); |
caf70cb2 | 1101 | err = PTR_ERR(index); |
e7dd0e71 | 1102 | if (IS_ERR(index)) { |
9f4ec904 | 1103 | index = NULL; |
e7dd0e71 AG |
1104 | } else if (ovl_index_all(dentry->d_sb)) { |
1105 | /* Whiteout orphan index to block future open by handle */ | |
c21c839b CX |
1106 | err = ovl_cleanup_and_whiteout(OVL_FS(dentry->d_sb), |
1107 | dir, index); | |
e7dd0e71 AG |
1108 | } else { |
1109 | /* Cleanup orphan index entries */ | |
576bb263 | 1110 | err = ovl_cleanup(ofs, dir, index); |
e7dd0e71 | 1111 | } |
9f4ec904 | 1112 | |
caf70cb2 AG |
1113 | inode_unlock(dir); |
1114 | if (err) | |
1115 | goto fail; | |
1116 | ||
1117 | out: | |
5b02bfc1 AG |
1118 | if (got_write) |
1119 | ovl_drop_write(dentry); | |
63e13252 | 1120 | kfree(name.name); |
caf70cb2 AG |
1121 | dput(index); |
1122 | return; | |
1123 | ||
1124 | fail: | |
1bd0a3ae | 1125 | pr_err("cleanup index of '%pd2' failed (%i)\n", dentry, err); |
caf70cb2 AG |
1126 | goto out; |
1127 | } | |
1128 | ||
5f8415d6 AG |
1129 | /* |
1130 | * Operations that change overlay inode and upper inode nlink need to be | |
1131 | * synchronized with copy up for persistent nlink accounting. | |
1132 | */ | |
0e32992f | 1133 | int ovl_nlink_start(struct dentry *dentry) |
5f8415d6 | 1134 | { |
1e92e307 | 1135 | struct inode *inode = d_inode(dentry); |
5f8415d6 AG |
1136 | const struct cred *old_cred; |
1137 | int err; | |
1138 | ||
1e92e307 | 1139 | if (WARN_ON(!inode)) |
0e32992f | 1140 | return -ENOENT; |
5f8415d6 AG |
1141 | |
1142 | /* | |
1143 | * With inodes index is enabled, we store the union overlay nlink | |
24b33ee1 | 1144 | * in an xattr on the index inode. When whiting out an indexed lower, |
5f8415d6 AG |
1145 | * we need to decrement the overlay persistent nlink, but before the |
1146 | * first copy up, we have no upper index inode to store the xattr. | |
1147 | * | |
24b33ee1 | 1148 | * As a workaround, before whiteout/rename over an indexed lower, |
5f8415d6 AG |
1149 | * copy up to create the upper index. Creating the upper index will |
1150 | * initialize the overlay nlink, so it could be dropped if unlink | |
1151 | * or rename succeeds. | |
1152 | * | |
1153 | * TODO: implement metadata only index copy up when called with | |
1154 | * ovl_copy_up_flags(dentry, O_PATH). | |
1155 | */ | |
24b33ee1 | 1156 | if (ovl_need_index(dentry) && !ovl_dentry_has_upper_alias(dentry)) { |
5f8415d6 AG |
1157 | err = ovl_copy_up(dentry); |
1158 | if (err) | |
1159 | return err; | |
1160 | } | |
1161 | ||
531d3040 | 1162 | err = ovl_inode_lock_interruptible(inode); |
5f8415d6 AG |
1163 | if (err) |
1164 | return err; | |
1165 | ||
162d0644 AG |
1166 | err = ovl_want_write(dentry); |
1167 | if (err) | |
1168 | goto out_unlock; | |
1169 | ||
1e92e307 | 1170 | if (d_is_dir(dentry) || !ovl_test_flag(OVL_INDEX, inode)) |
162d0644 | 1171 | return 0; |
5f8415d6 AG |
1172 | |
1173 | old_cred = ovl_override_creds(dentry->d_sb); | |
1174 | /* | |
1175 | * The overlay inode nlink should be incremented/decremented IFF the | |
1176 | * upper operation succeeds, along with nlink change of upper inode. | |
1177 | * Therefore, before link/unlink/rename, we store the union nlink | |
1178 | * value relative to the upper inode nlink in an upper inode xattr. | |
1179 | */ | |
1180 | err = ovl_set_nlink_upper(dentry); | |
1181 | revert_creds(old_cred); | |
5f8415d6 | 1182 | if (err) |
162d0644 AG |
1183 | goto out_drop_write; |
1184 | ||
1185 | return 0; | |
1186 | ||
1187 | out_drop_write: | |
1188 | ovl_drop_write(dentry); | |
1189 | out_unlock: | |
1190 | ovl_inode_unlock(inode); | |
5f8415d6 AG |
1191 | |
1192 | return err; | |
1193 | } | |
1194 | ||
0e32992f | 1195 | void ovl_nlink_end(struct dentry *dentry) |
5f8415d6 | 1196 | { |
1e92e307 AG |
1197 | struct inode *inode = d_inode(dentry); |
1198 | ||
5b02bfc1 AG |
1199 | ovl_drop_write(dentry); |
1200 | ||
1e92e307 | 1201 | if (ovl_test_flag(OVL_INDEX, inode) && inode->i_nlink == 0) { |
0e32992f | 1202 | const struct cred *old_cred; |
caf70cb2 | 1203 | |
0e32992f AG |
1204 | old_cred = ovl_override_creds(dentry->d_sb); |
1205 | ovl_cleanup_index(dentry); | |
1206 | revert_creds(old_cred); | |
caf70cb2 | 1207 | } |
0e32992f | 1208 | |
1e92e307 | 1209 | ovl_inode_unlock(inode); |
5f8415d6 | 1210 | } |
5820dc08 AG |
1211 | |
1212 | int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir) | |
1213 | { | |
a8b00268 AV |
1214 | struct dentry *trap; |
1215 | ||
5820dc08 AG |
1216 | /* Workdir should not be the same as upperdir */ |
1217 | if (workdir == upperdir) | |
1218 | goto err; | |
1219 | ||
1220 | /* Workdir should not be subdir of upperdir and vice versa */ | |
a8b00268 AV |
1221 | trap = lock_rename(workdir, upperdir); |
1222 | if (IS_ERR(trap)) | |
1223 | goto err; | |
1224 | if (trap) | |
5820dc08 AG |
1225 | goto err_unlock; |
1226 | ||
1227 | return 0; | |
1228 | ||
1229 | err_unlock: | |
1230 | unlock_rename(workdir, upperdir); | |
1231 | err: | |
1bd0a3ae | 1232 | pr_err("failed to lock workdir+upperdir\n"); |
5820dc08 AG |
1233 | return -EIO; |
1234 | } | |
9d3dfea3 | 1235 | |
bf070890 AL |
1236 | /* |
1237 | * err < 0, 0 if no metacopy xattr, metacopy data size if xattr found. | |
1238 | * an empty xattr returns OVL_METACOPY_MIN_SIZE to distinguish from no xattr value. | |
1239 | */ | |
1240 | int ovl_check_metacopy_xattr(struct ovl_fs *ofs, const struct path *path, | |
1241 | struct ovl_metacopy *data) | |
9d3dfea3 VG |
1242 | { |
1243 | int res; | |
1244 | ||
1245 | /* Only regular files can have metacopy xattr */ | |
dad7017a | 1246 | if (!S_ISREG(d_inode(path->dentry)->i_mode)) |
9d3dfea3 VG |
1247 | return 0; |
1248 | ||
bf070890 AL |
1249 | res = ovl_path_getxattr(ofs, path, OVL_XATTR_METACOPY, |
1250 | data, data ? OVL_METACOPY_MAX_SIZE : 0); | |
9d3dfea3 VG |
1251 | if (res < 0) { |
1252 | if (res == -ENODATA || res == -EOPNOTSUPP) | |
1253 | return 0; | |
87b2c60c MS |
1254 | /* |
1255 | * getxattr on user.* may fail with EACCES in case there's no | |
1256 | * read permission on the inode. Not much we can do, other than | |
1257 | * tell the caller that this is not a metacopy inode. | |
1258 | */ | |
1259 | if (ofs->config.userxattr && res == -EACCES) | |
1260 | return 0; | |
9d3dfea3 VG |
1261 | goto out; |
1262 | } | |
1263 | ||
bf070890 AL |
1264 | if (res == 0) { |
1265 | /* Emulate empty data for zero size metacopy xattr */ | |
1266 | res = OVL_METACOPY_MIN_SIZE; | |
1267 | if (data) { | |
1268 | memset(data, 0, res); | |
1269 | data->len = res; | |
1270 | } | |
1271 | } else if (res < OVL_METACOPY_MIN_SIZE) { | |
1272 | pr_warn_ratelimited("metacopy file '%pd' has too small xattr\n", | |
1273 | path->dentry); | |
1274 | return -EIO; | |
1275 | } else if (data) { | |
1276 | if (data->version != 0) { | |
1277 | pr_warn_ratelimited("metacopy file '%pd' has unsupported version\n", | |
1278 | path->dentry); | |
1279 | return -EIO; | |
1280 | } | |
1281 | if (res != data->len) { | |
1282 | pr_warn_ratelimited("metacopy file '%pd' has invalid xattr size\n", | |
1283 | path->dentry); | |
1284 | return -EIO; | |
1285 | } | |
1286 | } | |
1287 | ||
1288 | return res; | |
9d3dfea3 | 1289 | out: |
1bd0a3ae | 1290 | pr_warn_ratelimited("failed to get metacopy (%i)\n", res); |
9d3dfea3 VG |
1291 | return res; |
1292 | } | |
67d756c2 | 1293 | |
184996e9 AL |
1294 | int ovl_set_metacopy_xattr(struct ovl_fs *ofs, struct dentry *d, struct ovl_metacopy *metacopy) |
1295 | { | |
1296 | size_t len = metacopy->len; | |
1297 | ||
1298 | /* If no flags or digest fall back to empty metacopy file */ | |
1299 | if (metacopy->version == 0 && metacopy->flags == 0 && metacopy->digest_algo == 0) | |
1300 | len = 0; | |
1301 | ||
1302 | return ovl_check_setxattr(ofs, d, OVL_XATTR_METACOPY, | |
1303 | metacopy, len, -EOPNOTSUPP); | |
1304 | } | |
1305 | ||
67d756c2 VG |
1306 | bool ovl_is_metacopy_dentry(struct dentry *dentry) |
1307 | { | |
a6ff2bc0 | 1308 | struct ovl_entry *oe = OVL_E(dentry); |
67d756c2 VG |
1309 | |
1310 | if (!d_is_reg(dentry)) | |
1311 | return false; | |
1312 | ||
1313 | if (ovl_dentry_upper(dentry)) { | |
1314 | if (!ovl_has_upperdata(d_inode(dentry))) | |
1315 | return true; | |
1316 | return false; | |
1317 | } | |
1318 | ||
5522c9c7 | 1319 | return (ovl_numlower(oe) > 1); |
67d756c2 | 1320 | } |
0a2d0d3f | 1321 | |
2d343087 | 1322 | char *ovl_get_redirect_xattr(struct ovl_fs *ofs, const struct path *path, int padding) |
993a0b2a VG |
1323 | { |
1324 | int res; | |
1325 | char *s, *next, *buf = NULL; | |
1326 | ||
dad7017a | 1327 | res = ovl_path_getxattr(ofs, path, OVL_XATTR_REDIRECT, NULL, 0); |
92f0d6c9 | 1328 | if (res == -ENODATA || res == -EOPNOTSUPP) |
993a0b2a | 1329 | return NULL; |
0a2d0d3f | 1330 | if (res < 0) |
92f0d6c9 MS |
1331 | goto fail; |
1332 | if (res == 0) | |
1333 | goto invalid; | |
1334 | ||
1335 | buf = kzalloc(res + padding + 1, GFP_KERNEL); | |
1336 | if (!buf) | |
1337 | return ERR_PTR(-ENOMEM); | |
1338 | ||
dad7017a | 1339 | res = ovl_path_getxattr(ofs, path, OVL_XATTR_REDIRECT, buf, res); |
92f0d6c9 MS |
1340 | if (res < 0) |
1341 | goto fail; | |
0a2d0d3f VG |
1342 | if (res == 0) |
1343 | goto invalid; | |
1344 | ||
1345 | if (buf[0] == '/') { | |
1346 | for (s = buf; *s++ == '/'; s = next) { | |
1347 | next = strchrnul(s, '/'); | |
1348 | if (s == next) | |
1349 | goto invalid; | |
1350 | } | |
1351 | } else { | |
1352 | if (strchr(buf, '/') != NULL) | |
1353 | goto invalid; | |
1354 | } | |
1355 | ||
1356 | return buf; | |
0a2d0d3f | 1357 | invalid: |
1bd0a3ae | 1358 | pr_warn_ratelimited("invalid redirect (%s)\n", buf); |
0a2d0d3f | 1359 | res = -EINVAL; |
92f0d6c9 MS |
1360 | goto err_free; |
1361 | fail: | |
1362 | pr_warn_ratelimited("failed to get redirect (%i)\n", res); | |
1363 | err_free: | |
993a0b2a VG |
1364 | kfree(buf); |
1365 | return ERR_PTR(res); | |
0a2d0d3f | 1366 | } |
335d3fc5 | 1367 | |
184996e9 | 1368 | /* Call with mounter creds as it may open the file */ |
0c71faf5 | 1369 | int ovl_ensure_verity_loaded(struct path *datapath) |
184996e9 AL |
1370 | { |
1371 | struct inode *inode = d_inode(datapath->dentry); | |
1372 | struct file *filp; | |
1373 | ||
1374 | if (!fsverity_active(inode) && IS_VERITY(inode)) { | |
1375 | /* | |
1376 | * If this inode was not yet opened, the verity info hasn't been | |
1377 | * loaded yet, so we need to do that here to force it into memory. | |
1378 | */ | |
1379 | filp = kernel_file_open(datapath, O_RDONLY, inode, current_cred()); | |
1380 | if (IS_ERR(filp)) | |
1381 | return PTR_ERR(filp); | |
1382 | fput(filp); | |
1383 | } | |
1384 | ||
1385 | return 0; | |
1386 | } | |
1387 | ||
1388 | int ovl_validate_verity(struct ovl_fs *ofs, | |
1389 | struct path *metapath, | |
1390 | struct path *datapath) | |
1391 | { | |
1392 | struct ovl_metacopy metacopy_data; | |
1393 | u8 actual_digest[FS_VERITY_MAX_DIGEST_SIZE]; | |
1394 | int xattr_digest_size, digest_size; | |
1395 | int xattr_size, err; | |
1396 | u8 verity_algo; | |
1397 | ||
1398 | if (!ofs->config.verity_mode || | |
1399 | /* Verity only works on regular files */ | |
1400 | !S_ISREG(d_inode(metapath->dentry)->i_mode)) | |
1401 | return 0; | |
1402 | ||
1403 | xattr_size = ovl_check_metacopy_xattr(ofs, metapath, &metacopy_data); | |
1404 | if (xattr_size < 0) | |
1405 | return xattr_size; | |
1406 | ||
1407 | if (!xattr_size || !metacopy_data.digest_algo) { | |
1408 | if (ofs->config.verity_mode == OVL_VERITY_REQUIRE) { | |
1409 | pr_warn_ratelimited("metacopy file '%pd' has no digest specified\n", | |
1410 | metapath->dentry); | |
1411 | return -EIO; | |
1412 | } | |
1413 | return 0; | |
1414 | } | |
1415 | ||
1416 | xattr_digest_size = ovl_metadata_digest_size(&metacopy_data); | |
1417 | ||
1418 | err = ovl_ensure_verity_loaded(datapath); | |
1419 | if (err < 0) { | |
1420 | pr_warn_ratelimited("lower file '%pd' failed to load fs-verity info\n", | |
1421 | datapath->dentry); | |
1422 | return -EIO; | |
1423 | } | |
1424 | ||
1425 | digest_size = fsverity_get_digest(d_inode(datapath->dentry), actual_digest, | |
1426 | &verity_algo, NULL); | |
1427 | if (digest_size == 0) { | |
1428 | pr_warn_ratelimited("lower file '%pd' has no fs-verity digest\n", datapath->dentry); | |
1429 | return -EIO; | |
1430 | } | |
1431 | ||
1432 | if (xattr_digest_size != digest_size || | |
1433 | metacopy_data.digest_algo != verity_algo || | |
1434 | memcmp(metacopy_data.digest, actual_digest, xattr_digest_size) != 0) { | |
1435 | pr_warn_ratelimited("lower file '%pd' has the wrong fs-verity digest\n", | |
1436 | datapath->dentry); | |
1437 | return -EIO; | |
1438 | } | |
1439 | ||
1440 | return 0; | |
1441 | } | |
1442 | ||
0c71faf5 AL |
1443 | int ovl_get_verity_digest(struct ovl_fs *ofs, struct path *src, |
1444 | struct ovl_metacopy *metacopy) | |
1445 | { | |
1446 | int err, digest_size; | |
1447 | ||
1448 | if (!ofs->config.verity_mode || !S_ISREG(d_inode(src->dentry)->i_mode)) | |
1449 | return 0; | |
1450 | ||
1451 | err = ovl_ensure_verity_loaded(src); | |
1452 | if (err < 0) { | |
1453 | pr_warn_ratelimited("lower file '%pd' failed to load fs-verity info\n", | |
1454 | src->dentry); | |
1455 | return -EIO; | |
1456 | } | |
1457 | ||
1458 | digest_size = fsverity_get_digest(d_inode(src->dentry), | |
1459 | metacopy->digest, &metacopy->digest_algo, NULL); | |
1460 | if (digest_size == 0 || | |
1461 | WARN_ON_ONCE(digest_size > FS_VERITY_MAX_DIGEST_SIZE)) { | |
1462 | if (ofs->config.verity_mode == OVL_VERITY_REQUIRE) { | |
1463 | pr_warn_ratelimited("lower file '%pd' has no fs-verity digest\n", | |
1464 | src->dentry); | |
1465 | return -EIO; | |
1466 | } | |
1467 | return 0; | |
1468 | } | |
1469 | ||
1470 | metacopy->len += digest_size; | |
1471 | return 0; | |
1472 | } | |
1473 | ||
335d3fc5 SD |
1474 | /* |
1475 | * ovl_sync_status() - Check fs sync status for volatile mounts | |
1476 | * | |
1477 | * Returns 1 if this is not a volatile mount and a real sync is required. | |
1478 | * | |
1479 | * Returns 0 if syncing can be skipped because mount is volatile, and no errors | |
1480 | * have occurred on the upperdir since the mount. | |
1481 | * | |
1482 | * Returns -errno if it is a volatile mount, and the error that occurred since | |
1483 | * the last mount. If the error code changes, it'll return the latest error | |
1484 | * code. | |
1485 | */ | |
1486 | ||
1487 | int ovl_sync_status(struct ovl_fs *ofs) | |
1488 | { | |
1489 | struct vfsmount *mnt; | |
1490 | ||
1491 | if (ovl_should_sync(ofs)) | |
1492 | return 1; | |
1493 | ||
1494 | mnt = ovl_upper_mnt(ofs); | |
1495 | if (!mnt) | |
1496 | return 0; | |
1497 | ||
1498 | return errseq_check(&mnt->mnt_sb->s_wb_err, ofs->errseq); | |
1499 | } | |
2878dffc CB |
1500 | |
1501 | /* | |
1502 | * ovl_copyattr() - copy inode attributes from layer to ovl inode | |
1503 | * | |
1504 | * When overlay copies inode information from an upper or lower layer to the | |
1505 | * relevant overlay inode it will apply the idmapping of the upper or lower | |
1506 | * layer when doing so ensuring that the ovl inode ownership will correctly | |
1507 | * reflect the ownership of the idmapped upper or lower layer. For example, an | |
1508 | * idmapped upper or lower layer mapping id 1001 to id 1000 will take care to | |
1509 | * map any lower or upper inode owned by id 1001 to id 1000. These mapping | |
1510 | * helpers are nops when the relevant layer isn't idmapped. | |
1511 | */ | |
1512 | void ovl_copyattr(struct inode *inode) | |
1513 | { | |
1514 | struct path realpath; | |
1515 | struct inode *realinode; | |
e67fe633 | 1516 | struct mnt_idmap *real_idmap; |
73db6a06 CB |
1517 | vfsuid_t vfsuid; |
1518 | vfsgid_t vfsgid; | |
2878dffc | 1519 | |
b2dd05f1 | 1520 | realinode = ovl_i_path_real(inode, &realpath); |
e67fe633 | 1521 | real_idmap = mnt_idmap(realpath.mnt); |
2878dffc | 1522 | |
f7621b11 | 1523 | spin_lock(&inode->i_lock); |
e67fe633 CB |
1524 | vfsuid = i_uid_into_vfsuid(real_idmap, realinode); |
1525 | vfsgid = i_gid_into_vfsgid(real_idmap, realinode); | |
73db6a06 CB |
1526 | |
1527 | inode->i_uid = vfsuid_into_kuid(vfsuid); | |
1528 | inode->i_gid = vfsgid_into_kgid(vfsgid); | |
2878dffc | 1529 | inode->i_mode = realinode->i_mode; |
4ddbd0f1 JL |
1530 | inode_set_atime_to_ts(inode, inode_get_atime(realinode)); |
1531 | inode_set_mtime_to_ts(inode, inode_get_mtime(realinode)); | |
9aa71115 | 1532 | inode_set_ctime_to_ts(inode, inode_get_ctime(realinode)); |
2878dffc | 1533 | i_size_write(inode, i_size_read(realinode)); |
f7621b11 | 1534 | spin_unlock(&inode->i_lock); |
2878dffc | 1535 | } |