2 * Overlayfs NFS export support.
4 * Amir Goldstein <amir73il@gmail.com>
6 * Copyright (C) 2017-2018 CTERA Networks. All Rights Reserved.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published by
10 * the Free Software Foundation.
14 #include <linux/cred.h>
15 #include <linux/mount.h>
16 #include <linux/namei.h>
17 #include <linux/xattr.h>
18 #include <linux/exportfs.h>
19 #include <linux/ratelimit.h>
20 #include "overlayfs.h"
23 * We only need to encode origin if there is a chance that the same object was
24 * encoded pre copy up and then we need to stay consistent with the same
25 * encoding also after copy up. If non-pure upper is not indexed, then it was
26 * copied up before NFS export was enabled. In that case we don't need to worry
27 * about staying consistent with pre copy up encoding and we encode an upper
28 * file handle. Overlay root dentry is a private case of non-indexed upper.
30 * The following table summarizes the different file handle encodings used for
31 * different overlay object types:
33 * Object type | Encoding
34 * --------------------------------
36 * Non-indexed upper | U
37 * Indexed upper | L (*)
40 * U = upper file handle
41 * L = lower file handle
43 * (*) Connecting an overlay dir from real lower dentry is not always
44 * possible when there are redirects in lower layers. To mitigate this case,
45 * we copy up the lower dir first and then encode an upper dir file handle.
47 static bool ovl_should_encode_origin(struct dentry *dentry)
49 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
51 if (!ovl_dentry_lower(dentry))
55 * Decoding a merge dir, whose origin's parent is under a redirected
56 * lower dir is not always possible. As a simple aproximation, we do
57 * not encode lower dir file handles when overlay has multiple lower
58 * layers and origin is below the topmost lower layer.
60 * TODO: copy up only the parent that is under redirected lower.
62 if (d_is_dir(dentry) && ofs->upper_mnt &&
63 OVL_E(dentry)->lowerstack[0].layer->idx > 1)
66 /* Decoding a non-indexed upper from origin is not implemented */
67 if (ovl_dentry_upper(dentry) &&
68 !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
74 static int ovl_encode_maybe_copy_up(struct dentry *dentry)
78 if (ovl_dentry_upper(dentry))
81 err = ovl_want_write(dentry);
85 err = ovl_copy_up(dentry);
87 ovl_drop_write(dentry);
91 static int ovl_d_to_fh(struct dentry *dentry, char *buf, int buflen)
93 struct dentry *origin = ovl_dentry_lower(dentry);
94 struct ovl_fh *fh = NULL;
98 * If we should not encode a lower dir file handle, copy up and encode
99 * an upper dir file handle.
101 if (!ovl_should_encode_origin(dentry)) {
102 err = ovl_encode_maybe_copy_up(dentry);
109 /* Encode an upper or origin file handle */
110 fh = ovl_encode_fh(origin ?: ovl_dentry_upper(dentry), !origin);
113 if (fh->len > buflen)
116 memcpy(buf, (char *)fh, fh->len);
124 pr_warn_ratelimited("overlayfs: failed to encode file handle (%pd2, err=%i, buflen=%d, len=%d, type=%d)\n",
125 dentry, err, buflen, fh ? (int)fh->len : 0,
130 static int ovl_dentry_to_fh(struct dentry *dentry, u32 *fid, int *max_len)
132 int res, len = *max_len << 2;
134 res = ovl_d_to_fh(dentry, (char *)fid, len);
136 return FILEID_INVALID;
140 /* Round up to dwords */
141 *max_len = (len + 3) >> 2;
145 static int ovl_encode_inode_fh(struct inode *inode, u32 *fid, int *max_len,
146 struct inode *parent)
148 struct dentry *dentry;
151 /* TODO: encode connectable file handles */
153 return FILEID_INVALID;
155 dentry = d_find_any_alias(inode);
156 if (WARN_ON(!dentry))
157 return FILEID_INVALID;
159 type = ovl_dentry_to_fh(dentry, fid, max_len);
166 * Find or instantiate an overlay dentry from real dentries and index.
168 static struct dentry *ovl_obtain_alias(struct super_block *sb,
169 struct dentry *upper_alias,
170 struct ovl_path *lowerpath,
171 struct dentry *index)
173 struct dentry *lower = lowerpath ? lowerpath->dentry : NULL;
174 struct dentry *upper = upper_alias ?: index;
175 struct dentry *dentry;
177 struct ovl_entry *oe;
179 /* We get overlay directory dentries with ovl_lookup_real() */
180 if (d_is_dir(upper ?: lower))
181 return ERR_PTR(-EIO);
183 inode = ovl_get_inode(sb, dget(upper), lower, index, !!lower);
186 return ERR_CAST(inode);
190 ovl_set_flag(OVL_INDEX, inode);
192 dentry = d_find_any_alias(inode);
194 dentry = d_alloc_anon(inode->i_sb);
197 oe = ovl_alloc_entry(lower ? 1 : 0);
202 oe->lowerstack->dentry = dget(lower);
203 oe->lowerstack->layer = lowerpath->layer;
205 dentry->d_fsdata = oe;
207 ovl_dentry_set_upper_alias(dentry);
210 return d_instantiate_anon(dentry, inode);
215 return ERR_PTR(-ENOMEM);
219 * Lookup a child overlay dentry to get a connected overlay dentry whose real
220 * dentry is @real. If @real is on upper layer, we lookup a child overlay
221 * dentry with the same name as the real dentry. Otherwise, we need to consult
224 static struct dentry *ovl_lookup_real_one(struct dentry *connected,
226 struct ovl_layer *layer)
228 struct inode *dir = d_inode(connected);
229 struct dentry *this, *parent = NULL;
230 struct name_snapshot name;
233 /* TODO: lookup by lower real dentry */
235 return ERR_PTR(-EACCES);
238 * Lookup child overlay dentry by real name. The dir mutex protects us
239 * from racing with overlay rename. If the overlay dentry that is above
240 * real has already been moved to a parent that is not under the
241 * connected overlay dir, we return -ECHILD and restart the lookup of
242 * connected real path from the top.
244 inode_lock_nested(dir, I_MUTEX_PARENT);
246 parent = dget_parent(real);
247 if (ovl_dentry_upper(connected) != parent)
251 * We also need to take a snapshot of real dentry name to protect us
252 * from racing with underlying layer rename. In this case, we don't
253 * care about returning ESTALE, only from dereferencing a free name
254 * pointer because we hold no lock on the real dentry.
256 take_dentry_name_snapshot(&name, real);
257 this = lookup_one_len(name.name, connected, strlen(name.name));
261 } else if (!this || !this->d_inode) {
265 } else if (ovl_dentry_upper(this) != real) {
272 release_dentry_name_snapshot(&name);
278 pr_warn_ratelimited("overlayfs: failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
279 real, layer->idx, connected, err);
285 * Lookup a connected overlay dentry whose real dentry is @real.
286 * If @real is on upper layer, we lookup a child overlay dentry with the same
287 * path the real dentry. Otherwise, we need to consult index for lookup.
289 static struct dentry *ovl_lookup_real(struct super_block *sb,
291 struct ovl_layer *layer)
293 struct dentry *connected;
296 /* TODO: use index when looking up by lower real dentry */
298 return ERR_PTR(-EACCES);
300 connected = dget(sb->s_root);
302 struct dentry *next, *this;
303 struct dentry *parent = NULL;
304 struct dentry *real_connected = ovl_dentry_upper(connected);
306 if (real_connected == real)
309 /* Find the topmost dentry not yet connected */
312 parent = dget_parent(next);
314 if (parent == real_connected)
318 * If real has been moved out of 'real_connected',
319 * we will not find 'real_connected' and hit the layer
320 * root. In that case, we need to restart connecting.
321 * This game can go on forever in the worst case. We
322 * may want to consider taking s_vfs_rename_mutex if
323 * this happens more than once.
325 if (parent == layer->mnt->mnt_root) {
327 connected = dget(sb->s_root);
332 * If real file has been moved out of the layer root
333 * directory, we will eventully hit the real fs root.
334 * This cannot happen by legit overlay rename, so we
335 * return error in that case.
337 if (parent == next) {
347 this = ovl_lookup_real_one(connected, next, layer);
352 * Lookup of child in overlay can fail when racing with
353 * overlay rename of child away from 'connected' parent.
354 * In this case, we need to restart the lookup from the
355 * top, because we cannot trust that 'real_connected' is
356 * still an ancestor of 'real'.
358 if (err == -ECHILD) {
359 this = dget(sb->s_root);
378 pr_warn_ratelimited("overlayfs: failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
379 real, layer->idx, connected, err);
385 * Get an overlay dentry from upper/lower real dentries and index.
387 static struct dentry *ovl_get_dentry(struct super_block *sb,
388 struct dentry *upper,
389 struct ovl_path *lowerpath,
390 struct dentry *index)
392 struct ovl_fs *ofs = sb->s_fs_info;
393 struct ovl_layer upper_layer = { .mnt = ofs->upper_mnt };
394 struct dentry *real = upper ?: (index ?: lowerpath->dentry);
397 * Obtain a disconnected overlay dentry from a non-dir real dentry
401 return ovl_obtain_alias(sb, upper, lowerpath, index);
403 /* TODO: lookup connected dir from real lower dir */
405 return ERR_PTR(-EACCES);
407 /* Removed empty directory? */
408 if ((upper->d_flags & DCACHE_DISCONNECTED) || d_unhashed(upper))
409 return ERR_PTR(-ENOENT);
412 * If real upper dentry is connected and hashed, get a connected
413 * overlay dentry with the same path as the real upper dentry.
415 return ovl_lookup_real(sb, upper, &upper_layer);
418 static struct dentry *ovl_upper_fh_to_d(struct super_block *sb,
421 struct ovl_fs *ofs = sb->s_fs_info;
422 struct dentry *dentry;
423 struct dentry *upper;
426 return ERR_PTR(-EACCES);
428 upper = ovl_decode_fh(fh, ofs->upper_mnt);
429 if (IS_ERR_OR_NULL(upper))
432 dentry = ovl_get_dentry(sb, upper, NULL, NULL);
438 static struct dentry *ovl_lower_fh_to_d(struct super_block *sb,
441 struct ovl_fs *ofs = sb->s_fs_info;
442 struct ovl_path origin = { };
443 struct ovl_path *stack = &origin;
444 struct dentry *dentry = NULL;
445 struct dentry *index = NULL;
446 struct inode *inode = NULL;
447 bool is_deleted = false;
450 /* First lookup indexed upper by fh */
452 index = ovl_get_index_fh(ofs, fh);
453 err = PTR_ERR(index);
458 /* Found a whiteout index - treat as deleted inode */
464 /* Then try to get upper dir by index */
465 if (index && d_is_dir(index)) {
466 struct dentry *upper = ovl_index_upper(ofs, index);
468 err = PTR_ERR(upper);
469 if (IS_ERR_OR_NULL(upper))
472 dentry = ovl_get_dentry(sb, upper, NULL, NULL);
477 /* Then lookup origin by fh */
478 err = ovl_check_origin_fh(ofs, fh, NULL, &stack);
482 err = ovl_verify_origin(index, origin.dentry, false);
485 } else if (is_deleted) {
486 /* Lookup deleted non-dir by origin inode */
487 if (!d_is_dir(origin.dentry))
488 inode = ovl_lookup_inode(sb, origin.dentry);
490 if (!inode || atomic_read(&inode->i_count) == 1)
493 /* Deleted but still open? */
494 index = dget(ovl_i_dentry_upper(inode));
497 dentry = ovl_get_dentry(sb, NULL, &origin, index);
506 dentry = ERR_PTR(err);
510 static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid,
511 int fh_len, int fh_type)
513 struct dentry *dentry = NULL;
514 struct ovl_fh *fh = (struct ovl_fh *) fid;
515 int len = fh_len << 2;
516 unsigned int flags = 0;
520 if (fh_type != OVL_FILEID)
523 err = ovl_check_fh_len(fh, len);
528 dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ?
529 ovl_upper_fh_to_d(sb, fh) :
530 ovl_lower_fh_to_d(sb, fh);
531 err = PTR_ERR(dentry);
532 if (IS_ERR(dentry) && err != -ESTALE)
538 pr_warn_ratelimited("overlayfs: failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",
539 len, fh_type, flags, err);
543 static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,
544 int fh_len, int fh_type)
546 pr_warn_ratelimited("overlayfs: connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");
547 return ERR_PTR(-EACCES);
550 static int ovl_get_name(struct dentry *parent, char *name,
551 struct dentry *child)
554 * ovl_fh_to_dentry() returns connected dir overlay dentries and
555 * ovl_fh_to_parent() is not implemented, so we should not get here.
561 static struct dentry *ovl_get_parent(struct dentry *dentry)
564 * ovl_fh_to_dentry() returns connected dir overlay dentries, so we
565 * should not get here.
568 return ERR_PTR(-EIO);
571 const struct export_operations ovl_export_operations = {
572 .encode_fh = ovl_encode_inode_fh,
573 .fh_to_dentry = ovl_fh_to_dentry,
574 .fh_to_parent = ovl_fh_to_parent,
575 .get_name = ovl_get_name,
576 .get_parent = ovl_get_parent,