1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 28ed5eec9SAmir Goldstein /* 38ed5eec9SAmir Goldstein * Overlayfs NFS export support. 48ed5eec9SAmir Goldstein * 58ed5eec9SAmir Goldstein * Amir Goldstein <amir73il@gmail.com> 68ed5eec9SAmir Goldstein * 78ed5eec9SAmir Goldstein * Copyright (C) 2017-2018 CTERA Networks. All Rights Reserved. 88ed5eec9SAmir Goldstein */ 98ed5eec9SAmir Goldstein 108ed5eec9SAmir Goldstein #include <linux/fs.h> 118ed5eec9SAmir Goldstein #include <linux/cred.h> 128ed5eec9SAmir Goldstein #include <linux/mount.h> 138ed5eec9SAmir Goldstein #include <linux/namei.h> 148ed5eec9SAmir Goldstein #include <linux/xattr.h> 158ed5eec9SAmir Goldstein #include <linux/exportfs.h> 168ed5eec9SAmir Goldstein #include <linux/ratelimit.h> 178ed5eec9SAmir Goldstein #include "overlayfs.h" 188ed5eec9SAmir Goldstein 192ca3c148SAmir Goldstein static int ovl_encode_maybe_copy_up(struct dentry *dentry) 202ca3c148SAmir Goldstein { 212ca3c148SAmir Goldstein int err; 222ca3c148SAmir Goldstein 232ca3c148SAmir Goldstein if (ovl_dentry_upper(dentry)) 242ca3c148SAmir Goldstein return 0; 252ca3c148SAmir Goldstein 262ca3c148SAmir Goldstein err = ovl_want_write(dentry); 272ca3c148SAmir Goldstein if (!err) { 282ca3c148SAmir Goldstein err = ovl_copy_up(dentry); 292ca3c148SAmir Goldstein ovl_drop_write(dentry); 302ca3c148SAmir Goldstein } 312ca3c148SAmir Goldstein 322ca3c148SAmir Goldstein if (err) { 331bd0a3aeSlijiazi pr_warn_ratelimited("failed to copy up on encode (%pd2, err=%i)\n", 342ca3c148SAmir Goldstein dentry, err); 352ca3c148SAmir Goldstein } 362ca3c148SAmir Goldstein 372ca3c148SAmir Goldstein return err; 382ca3c148SAmir Goldstein } 392ca3c148SAmir Goldstein 402ca3c148SAmir Goldstein /* 412ca3c148SAmir Goldstein * Before encoding a non-upper directory file handle from real layer N, we need 422ca3c148SAmir Goldstein * to check if it will be possible to reconnect an overlay dentry from the real 432ca3c148SAmir Goldstein * lower decoded dentry. This is done by following the overlay ancestry up to a 442ca3c148SAmir Goldstein * "layer N connected" ancestor and verifying that all parents along the way are 452ca3c148SAmir Goldstein * "layer N connectable". If an ancestor that is NOT "layer N connectable" is 462ca3c148SAmir Goldstein * found, we need to copy up an ancestor, which is "layer N connectable", thus 472ca3c148SAmir Goldstein * making that ancestor "layer N connected". For example: 482ca3c148SAmir Goldstein * 492ca3c148SAmir Goldstein * layer 1: /a 502ca3c148SAmir Goldstein * layer 2: /a/b/c 512ca3c148SAmir Goldstein * 522ca3c148SAmir Goldstein * The overlay dentry /a is NOT "layer 2 connectable", because if dir /a is 532ca3c148SAmir Goldstein * copied up and renamed, upper dir /a will be indexed by lower dir /a from 542ca3c148SAmir Goldstein * layer 1. The dir /a from layer 2 will never be indexed, so the algorithm (*) 552ca3c148SAmir Goldstein * in ovl_lookup_real_ancestor() will not be able to lookup a connected overlay 562ca3c148SAmir Goldstein * dentry from the connected lower dentry /a/b/c. 572ca3c148SAmir Goldstein * 582ca3c148SAmir Goldstein * To avoid this problem on decode time, we need to copy up an ancestor of 592ca3c148SAmir Goldstein * /a/b/c, which is "layer 2 connectable", on encode time. That ancestor is 602ca3c148SAmir Goldstein * /a/b. After copy up (and index) of /a/b, it will become "layer 2 connected" 612ca3c148SAmir Goldstein * and when the time comes to decode the file handle from lower dentry /a/b/c, 622ca3c148SAmir Goldstein * ovl_lookup_real_ancestor() will find the indexed ancestor /a/b and decoding 632ca3c148SAmir Goldstein * a connected overlay dentry will be accomplished. 642ca3c148SAmir Goldstein * 652ca3c148SAmir Goldstein * (*) the algorithm in ovl_lookup_real_ancestor() can be improved to lookup an 662ca3c148SAmir Goldstein * entry /a in the lower layers above layer N and find the indexed dir /a from 672ca3c148SAmir Goldstein * layer 1. If that improvement is made, then the check for "layer N connected" 682ca3c148SAmir Goldstein * will need to verify there are no redirects in lower layers above N. In the 692ca3c148SAmir Goldstein * example above, /a will be "layer 2 connectable". However, if layer 2 dir /a 702ca3c148SAmir Goldstein * is a target of a layer 1 redirect, then /a will NOT be "layer 2 connectable": 712ca3c148SAmir Goldstein * 722ca3c148SAmir Goldstein * layer 1: /A (redirect = /a) 732ca3c148SAmir Goldstein * layer 2: /a/b/c 742ca3c148SAmir Goldstein */ 752ca3c148SAmir Goldstein 762ca3c148SAmir Goldstein /* Return the lowest layer for encoding a connectable file handle */ 772ca3c148SAmir Goldstein static int ovl_connectable_layer(struct dentry *dentry) 782ca3c148SAmir Goldstein { 792ca3c148SAmir Goldstein struct ovl_entry *oe = OVL_E(dentry); 802ca3c148SAmir Goldstein 812ca3c148SAmir Goldstein /* We can get overlay root from root of any layer */ 822ca3c148SAmir Goldstein if (dentry == dentry->d_sb->s_root) 835522c9c7SAmir Goldstein return ovl_numlower(oe); 842ca3c148SAmir Goldstein 852ca3c148SAmir Goldstein /* 862ca3c148SAmir Goldstein * If it's an unindexed merge dir, then it's not connectable with any 872ca3c148SAmir Goldstein * lower layer 882ca3c148SAmir Goldstein */ 892ca3c148SAmir Goldstein if (ovl_dentry_upper(dentry) && 902ca3c148SAmir Goldstein !ovl_test_flag(OVL_INDEX, d_inode(dentry))) 912ca3c148SAmir Goldstein return 0; 922ca3c148SAmir Goldstein 932ca3c148SAmir Goldstein /* We can get upper/overlay path from indexed/lower dentry */ 945522c9c7SAmir Goldstein return ovl_lowerstack(oe)->layer->idx; 952ca3c148SAmir Goldstein } 962ca3c148SAmir Goldstein 972ca3c148SAmir Goldstein /* 982ca3c148SAmir Goldstein * @dentry is "connected" if all ancestors up to root or a "connected" ancestor 992ca3c148SAmir Goldstein * have the same uppermost lower layer as the origin's layer. We may need to 1002ca3c148SAmir Goldstein * copy up a "connectable" ancestor to make it "connected". A "connected" dentry 1012ca3c148SAmir Goldstein * cannot become non "connected", so cache positive result in dentry flags. 1022ca3c148SAmir Goldstein * 1032ca3c148SAmir Goldstein * Return the connected origin layer or < 0 on error. 1042ca3c148SAmir Goldstein */ 1052ca3c148SAmir Goldstein static int ovl_connect_layer(struct dentry *dentry) 1062ca3c148SAmir Goldstein { 1072ca3c148SAmir Goldstein struct dentry *next, *parent = NULL; 1085522c9c7SAmir Goldstein struct ovl_entry *oe = OVL_E(dentry); 1092ca3c148SAmir Goldstein int origin_layer; 1102ca3c148SAmir Goldstein int err = 0; 1112ca3c148SAmir Goldstein 1122ca3c148SAmir Goldstein if (WARN_ON(dentry == dentry->d_sb->s_root) || 1132ca3c148SAmir Goldstein WARN_ON(!ovl_dentry_lower(dentry))) 1142ca3c148SAmir Goldstein return -EIO; 1152ca3c148SAmir Goldstein 1165522c9c7SAmir Goldstein origin_layer = ovl_lowerstack(oe)->layer->idx; 1172ca3c148SAmir Goldstein if (ovl_dentry_test_flag(OVL_E_CONNECTED, dentry)) 1182ca3c148SAmir Goldstein return origin_layer; 1192ca3c148SAmir Goldstein 1202ca3c148SAmir Goldstein /* Find the topmost origin layer connectable ancestor of @dentry */ 1212ca3c148SAmir Goldstein next = dget(dentry); 1222ca3c148SAmir Goldstein for (;;) { 1232ca3c148SAmir Goldstein parent = dget_parent(next); 1242ca3c148SAmir Goldstein if (WARN_ON(parent == next)) { 1252ca3c148SAmir Goldstein err = -EIO; 1262ca3c148SAmir Goldstein break; 1272ca3c148SAmir Goldstein } 1282ca3c148SAmir Goldstein 1292ca3c148SAmir Goldstein /* 1302ca3c148SAmir Goldstein * If @parent is not origin layer connectable, then copy up 1312ca3c148SAmir Goldstein * @next which is origin layer connectable and we are done. 1322ca3c148SAmir Goldstein */ 1332ca3c148SAmir Goldstein if (ovl_connectable_layer(parent) < origin_layer) { 1342ca3c148SAmir Goldstein err = ovl_encode_maybe_copy_up(next); 1352ca3c148SAmir Goldstein break; 1362ca3c148SAmir Goldstein } 1372ca3c148SAmir Goldstein 1382ca3c148SAmir Goldstein /* If @parent is connected or indexed we are done */ 1392ca3c148SAmir Goldstein if (ovl_dentry_test_flag(OVL_E_CONNECTED, parent) || 1402ca3c148SAmir Goldstein ovl_test_flag(OVL_INDEX, d_inode(parent))) 1412ca3c148SAmir Goldstein break; 1422ca3c148SAmir Goldstein 1432ca3c148SAmir Goldstein dput(next); 1442ca3c148SAmir Goldstein next = parent; 1452ca3c148SAmir Goldstein } 1462ca3c148SAmir Goldstein 1472ca3c148SAmir Goldstein dput(parent); 1482ca3c148SAmir Goldstein dput(next); 1492ca3c148SAmir Goldstein 1502ca3c148SAmir Goldstein if (!err) 1512ca3c148SAmir Goldstein ovl_dentry_set_flag(OVL_E_CONNECTED, dentry); 1522ca3c148SAmir Goldstein 1532ca3c148SAmir Goldstein return err ?: origin_layer; 1542ca3c148SAmir Goldstein } 1552ca3c148SAmir Goldstein 156b305e844SAmir Goldstein /* 157b305e844SAmir Goldstein * We only need to encode origin if there is a chance that the same object was 158b305e844SAmir Goldstein * encoded pre copy up and then we need to stay consistent with the same 159b305e844SAmir Goldstein * encoding also after copy up. If non-pure upper is not indexed, then it was 160b305e844SAmir Goldstein * copied up before NFS export was enabled. In that case we don't need to worry 161b305e844SAmir Goldstein * about staying consistent with pre copy up encoding and we encode an upper 162b305e844SAmir Goldstein * file handle. Overlay root dentry is a private case of non-indexed upper. 163b305e844SAmir Goldstein * 164b305e844SAmir Goldstein * The following table summarizes the different file handle encodings used for 165b305e844SAmir Goldstein * different overlay object types: 166b305e844SAmir Goldstein * 167b305e844SAmir Goldstein * Object type | Encoding 168b305e844SAmir Goldstein * -------------------------------- 169b305e844SAmir Goldstein * Pure upper | U 170b305e844SAmir Goldstein * Non-indexed upper | U 17105e1f118SAmir Goldstein * Indexed upper | L (*) 17205e1f118SAmir Goldstein * Non-upper | L (*) 173b305e844SAmir Goldstein * 174b305e844SAmir Goldstein * U = upper file handle 175b305e844SAmir Goldstein * L = lower file handle 17605e1f118SAmir Goldstein * 17716aac5adSAmir Goldstein * (*) Decoding a connected overlay dir from real lower dentry is not always 1782ca3c148SAmir Goldstein * possible when there are redirects in lower layers and non-indexed merge dirs. 1792ca3c148SAmir Goldstein * To mitigate those case, we may copy up the lower dir ancestor before encode 18016aac5adSAmir Goldstein * of a decodable file handle for non-upper dir. 1812ca3c148SAmir Goldstein * 1822ca3c148SAmir Goldstein * Return 0 for upper file handle, > 0 for lower file handle or < 0 on error. 183b305e844SAmir Goldstein */ 1842ca3c148SAmir Goldstein static int ovl_check_encode_origin(struct dentry *dentry) 185b305e844SAmir Goldstein { 186*f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(dentry->d_sb); 18716aac5adSAmir Goldstein bool decodable = ofs->config.nfs_export; 18816aac5adSAmir Goldstein 18916aac5adSAmir Goldstein /* Lower file handle for non-upper non-decodable */ 19016aac5adSAmir Goldstein if (!ovl_dentry_upper(dentry) && !decodable) 19116aac5adSAmir Goldstein return 0; 19205e1f118SAmir Goldstein 1932ca3c148SAmir Goldstein /* Upper file handle for pure upper */ 194b305e844SAmir Goldstein if (!ovl_dentry_lower(dentry)) 19505e1f118SAmir Goldstein return 0; 19605e1f118SAmir Goldstein 1972ca3c148SAmir Goldstein /* 1982ca3c148SAmir Goldstein * Root is never indexed, so if there's an upper layer, encode upper for 1992ca3c148SAmir Goldstein * root. 2002ca3c148SAmir Goldstein */ 20116aac5adSAmir Goldstein if (dentry == dentry->d_sb->s_root) 20216aac5adSAmir Goldstein return 0; 20316aac5adSAmir Goldstein 20416aac5adSAmir Goldstein /* 20516aac5adSAmir Goldstein * Upper decodable file handle for non-indexed upper. 20616aac5adSAmir Goldstein */ 20716aac5adSAmir Goldstein if (ovl_dentry_upper(dentry) && decodable && 2082ca3c148SAmir Goldstein !ovl_test_flag(OVL_INDEX, d_inode(dentry))) 2092ca3c148SAmir Goldstein return 0; 21005e1f118SAmir Goldstein 2112ca3c148SAmir Goldstein /* 2122ca3c148SAmir Goldstein * Decoding a merge dir, whose origin's ancestor is under a redirected 2132ca3c148SAmir Goldstein * lower dir or under a non-indexed upper is not always possible. 2142ca3c148SAmir Goldstein * ovl_connect_layer() will try to make origin's layer "connected" by 2152ca3c148SAmir Goldstein * copying up a "connectable" ancestor. 2162ca3c148SAmir Goldstein */ 21716aac5adSAmir Goldstein if (d_is_dir(dentry) && ovl_upper_mnt(ofs) && decodable) 2182ca3c148SAmir Goldstein return ovl_connect_layer(dentry); 21905e1f118SAmir Goldstein 2202ca3c148SAmir Goldstein /* Lower file handle for indexed and non-upper dir/non-dir */ 2212ca3c148SAmir Goldstein return 1; 22205e1f118SAmir Goldstein } 22305e1f118SAmir Goldstein 2241cdb0cb6SPavel Tikhomirov static int ovl_dentry_to_fid(struct ovl_fs *ofs, struct dentry *dentry, 2251cdb0cb6SPavel Tikhomirov u32 *fid, int buflen) 2268ed5eec9SAmir Goldstein { 2278ed5eec9SAmir Goldstein struct ovl_fh *fh = NULL; 2282ca3c148SAmir Goldstein int err, enc_lower; 229cbe7fba8SAmir Goldstein int len; 2308ed5eec9SAmir Goldstein 23105e1f118SAmir Goldstein /* 2322ca3c148SAmir Goldstein * Check if we should encode a lower or upper file handle and maybe 2332ca3c148SAmir Goldstein * copy up an ancestor to make lower file handle connectable. 23405e1f118SAmir Goldstein */ 2352ca3c148SAmir Goldstein err = enc_lower = ovl_check_encode_origin(dentry); 2362ca3c148SAmir Goldstein if (enc_lower < 0) 23705e1f118SAmir Goldstein goto fail; 2388ed5eec9SAmir Goldstein 2392ca3c148SAmir Goldstein /* Encode an upper or lower file handle */ 2401cdb0cb6SPavel Tikhomirov fh = ovl_encode_real_fh(ofs, enc_lower ? ovl_dentry_lower(dentry) : 2412ca3c148SAmir Goldstein ovl_dentry_upper(dentry), !enc_lower); 2429b6faee0SAmir Goldstein if (IS_ERR(fh)) 24397f024b9SDing Xiang return PTR_ERR(fh); 2448ed5eec9SAmir Goldstein 245cbe7fba8SAmir Goldstein len = OVL_FH_LEN(fh); 246144da23bSLubos Dolezel if (len <= buflen) 247cbe7fba8SAmir Goldstein memcpy(fid, fh, len); 248cbe7fba8SAmir Goldstein err = len; 2498ed5eec9SAmir Goldstein 2508ed5eec9SAmir Goldstein out: 2518ed5eec9SAmir Goldstein kfree(fh); 2528ed5eec9SAmir Goldstein return err; 2538ed5eec9SAmir Goldstein 2548ed5eec9SAmir Goldstein fail: 255144da23bSLubos Dolezel pr_warn_ratelimited("failed to encode file handle (%pd2, err=%i)\n", 256144da23bSLubos Dolezel dentry, err); 2578ed5eec9SAmir Goldstein goto out; 2588ed5eec9SAmir Goldstein } 2598ed5eec9SAmir Goldstein 2605b2cccd3SAmir Goldstein static int ovl_encode_fh(struct inode *inode, u32 *fid, int *max_len, 2618ed5eec9SAmir Goldstein struct inode *parent) 2628ed5eec9SAmir Goldstein { 2631cdb0cb6SPavel Tikhomirov struct ovl_fs *ofs = OVL_FS(inode->i_sb); 2648ed5eec9SAmir Goldstein struct dentry *dentry; 265144da23bSLubos Dolezel int bytes, buflen = *max_len << 2; 2668ed5eec9SAmir Goldstein 2678ed5eec9SAmir Goldstein /* TODO: encode connectable file handles */ 2688ed5eec9SAmir Goldstein if (parent) 2698ed5eec9SAmir Goldstein return FILEID_INVALID; 2708ed5eec9SAmir Goldstein 2718ed5eec9SAmir Goldstein dentry = d_find_any_alias(inode); 272dd524b7fSJiachen Zhang if (!dentry) 2738ed5eec9SAmir Goldstein return FILEID_INVALID; 2748ed5eec9SAmir Goldstein 2751cdb0cb6SPavel Tikhomirov bytes = ovl_dentry_to_fid(ofs, dentry, fid, buflen); 2768ed5eec9SAmir Goldstein dput(dentry); 277cbe7fba8SAmir Goldstein if (bytes <= 0) 278cbe7fba8SAmir Goldstein return FILEID_INVALID; 279cbe7fba8SAmir Goldstein 280cbe7fba8SAmir Goldstein *max_len = bytes >> 2; 281144da23bSLubos Dolezel if (bytes > buflen) 282144da23bSLubos Dolezel return FILEID_INVALID; 283cbe7fba8SAmir Goldstein 284cbe7fba8SAmir Goldstein return OVL_FILEID_V1; 2858ed5eec9SAmir Goldstein } 2868ed5eec9SAmir Goldstein 2878556a420SAmir Goldstein /* 288f71bd9cfSAmir Goldstein * Find or instantiate an overlay dentry from real dentries and index. 2898556a420SAmir Goldstein */ 2908556a420SAmir Goldstein static struct dentry *ovl_obtain_alias(struct super_block *sb, 291f71bd9cfSAmir Goldstein struct dentry *upper_alias, 292f71bd9cfSAmir Goldstein struct ovl_path *lowerpath, 293f71bd9cfSAmir Goldstein struct dentry *index) 2948556a420SAmir Goldstein { 295f941866fSAmir Goldstein struct dentry *lower = lowerpath ? lowerpath->dentry : NULL; 296f71bd9cfSAmir Goldstein struct dentry *upper = upper_alias ?: index; 2978556a420SAmir Goldstein struct dentry *dentry; 2980af950f5SAmir Goldstein struct inode *inode = NULL; 2998556a420SAmir Goldstein struct ovl_entry *oe; 300ac6a52ebSVivek Goyal struct ovl_inode_params oip = { 301ac6a52ebSVivek Goyal .index = index, 302ac6a52ebSVivek Goyal }; 3038556a420SAmir Goldstein 304f71bd9cfSAmir Goldstein /* We get overlay directory dentries with ovl_lookup_real() */ 305f71bd9cfSAmir Goldstein if (d_is_dir(upper ?: lower)) 3068556a420SAmir Goldstein return ERR_PTR(-EIO); 3078556a420SAmir Goldstein 3080af950f5SAmir Goldstein oe = ovl_alloc_entry(!!lower); 3090af950f5SAmir Goldstein if (!oe) 3100af950f5SAmir Goldstein return ERR_PTR(-ENOMEM); 3110af950f5SAmir Goldstein 312ac6a52ebSVivek Goyal oip.upperdentry = dget(upper); 3130af950f5SAmir Goldstein if (lower) { 3140af950f5SAmir Goldstein ovl_lowerstack(oe)->dentry = dget(lower); 3150af950f5SAmir Goldstein ovl_lowerstack(oe)->layer = lowerpath->layer; 3160af950f5SAmir Goldstein } 3170af950f5SAmir Goldstein oip.oe = oe; 318ac6a52ebSVivek Goyal inode = ovl_get_inode(sb, &oip); 3198556a420SAmir Goldstein if (IS_ERR(inode)) { 3200af950f5SAmir Goldstein ovl_free_entry(oe); 3218556a420SAmir Goldstein dput(upper); 3228556a420SAmir Goldstein return ERR_CAST(inode); 3238556a420SAmir Goldstein } 3248556a420SAmir Goldstein 3259d3dfea3SVivek Goyal if (upper) 3269d3dfea3SVivek Goyal ovl_set_flag(OVL_UPPERDATA, inode); 3279d3dfea3SVivek Goyal 3288556a420SAmir Goldstein dentry = d_find_any_alias(inode); 329504f3841SAl Viro if (dentry) 330504f3841SAl Viro goto out_iput; 331504f3841SAl Viro 3328556a420SAmir Goldstein dentry = d_alloc_anon(inode->i_sb); 333504f3841SAl Viro if (unlikely(!dentry)) 3348556a420SAmir Goldstein goto nomem; 3358556a420SAmir Goldstein 336f71bd9cfSAmir Goldstein if (upper_alias) 3378556a420SAmir Goldstein ovl_dentry_set_upper_alias(dentry); 338504f3841SAl Viro 3390af950f5SAmir Goldstein ovl_dentry_init_reval(dentry, upper, OVL_I_E(inode)); 3408556a420SAmir Goldstein 3418556a420SAmir Goldstein return d_instantiate_anon(dentry, inode); 3428556a420SAmir Goldstein 3438556a420SAmir Goldstein nomem: 3448556a420SAmir Goldstein dput(dentry); 345504f3841SAl Viro dentry = ERR_PTR(-ENOMEM); 346504f3841SAl Viro out_iput: 347504f3841SAl Viro iput(inode); 348504f3841SAl Viro return dentry; 3498556a420SAmir Goldstein } 3508556a420SAmir Goldstein 351cdf5c9d1SJiangshan Yi /* Get the upper or lower dentry in stack whose on layer @idx */ 35298892516SAmir Goldstein static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx) 35398892516SAmir Goldstein { 354a6ff2bc0SAmir Goldstein struct ovl_entry *oe = OVL_E(dentry); 3555522c9c7SAmir Goldstein struct ovl_path *lowerstack = ovl_lowerstack(oe); 35698892516SAmir Goldstein int i; 35798892516SAmir Goldstein 35898892516SAmir Goldstein if (!idx) 35998892516SAmir Goldstein return ovl_dentry_upper(dentry); 36098892516SAmir Goldstein 3615522c9c7SAmir Goldstein for (i = 0; i < ovl_numlower(oe); i++) { 3625522c9c7SAmir Goldstein if (lowerstack[i].layer->idx == idx) 3635522c9c7SAmir Goldstein return lowerstack[i].dentry; 36498892516SAmir Goldstein } 36598892516SAmir Goldstein 36698892516SAmir Goldstein return NULL; 36798892516SAmir Goldstein } 36898892516SAmir Goldstein 3693985b70aSAmir Goldstein /* 3703985b70aSAmir Goldstein * Lookup a child overlay dentry to get a connected overlay dentry whose real 3713985b70aSAmir Goldstein * dentry is @real. If @real is on upper layer, we lookup a child overlay 3723985b70aSAmir Goldstein * dentry with the same name as the real dentry. Otherwise, we need to consult 3733985b70aSAmir Goldstein * index for lookup. 3743985b70aSAmir Goldstein */ 3753985b70aSAmir Goldstein static struct dentry *ovl_lookup_real_one(struct dentry *connected, 3763985b70aSAmir Goldstein struct dentry *real, 37713464165SMiklos Szeredi const struct ovl_layer *layer) 3783985b70aSAmir Goldstein { 3793985b70aSAmir Goldstein struct inode *dir = d_inode(connected); 3803985b70aSAmir Goldstein struct dentry *this, *parent = NULL; 3813985b70aSAmir Goldstein struct name_snapshot name; 3823985b70aSAmir Goldstein int err; 3833985b70aSAmir Goldstein 3843985b70aSAmir Goldstein /* 3853985b70aSAmir Goldstein * Lookup child overlay dentry by real name. The dir mutex protects us 3863985b70aSAmir Goldstein * from racing with overlay rename. If the overlay dentry that is above 3873985b70aSAmir Goldstein * real has already been moved to a parent that is not under the 3883985b70aSAmir Goldstein * connected overlay dir, we return -ECHILD and restart the lookup of 3893985b70aSAmir Goldstein * connected real path from the top. 3903985b70aSAmir Goldstein */ 3913985b70aSAmir Goldstein inode_lock_nested(dir, I_MUTEX_PARENT); 3923985b70aSAmir Goldstein err = -ECHILD; 3933985b70aSAmir Goldstein parent = dget_parent(real); 39498892516SAmir Goldstein if (ovl_dentry_real_at(connected, layer->idx) != parent) 3953985b70aSAmir Goldstein goto fail; 3963985b70aSAmir Goldstein 3973985b70aSAmir Goldstein /* 3983985b70aSAmir Goldstein * We also need to take a snapshot of real dentry name to protect us 3993985b70aSAmir Goldstein * from racing with underlying layer rename. In this case, we don't 4003985b70aSAmir Goldstein * care about returning ESTALE, only from dereferencing a free name 4013985b70aSAmir Goldstein * pointer because we hold no lock on the real dentry. 4023985b70aSAmir Goldstein */ 4033985b70aSAmir Goldstein take_dentry_name_snapshot(&name, real); 404ba9ea771SChristian Brauner /* 4054609e1f1SChristian Brauner * No idmap handling here: it's an internal lookup. Could skip 4064609e1f1SChristian Brauner * permission checking altogether, but for now just use non-idmap 407ba9ea771SChristian Brauner * transformed ids. 408ba9ea771SChristian Brauner */ 409230c6402SAl Viro this = lookup_one_len(name.name.name, connected, name.name.len); 410580c6104SMiklos Szeredi release_dentry_name_snapshot(&name); 4113985b70aSAmir Goldstein err = PTR_ERR(this); 4123985b70aSAmir Goldstein if (IS_ERR(this)) { 4133985b70aSAmir Goldstein goto fail; 4143985b70aSAmir Goldstein } else if (!this || !this->d_inode) { 4153985b70aSAmir Goldstein dput(this); 4163985b70aSAmir Goldstein err = -ENOENT; 4173985b70aSAmir Goldstein goto fail; 41898892516SAmir Goldstein } else if (ovl_dentry_real_at(this, layer->idx) != real) { 4193985b70aSAmir Goldstein dput(this); 4203985b70aSAmir Goldstein err = -ESTALE; 4213985b70aSAmir Goldstein goto fail; 4223985b70aSAmir Goldstein } 4233985b70aSAmir Goldstein 4243985b70aSAmir Goldstein out: 4253985b70aSAmir Goldstein dput(parent); 4263985b70aSAmir Goldstein inode_unlock(dir); 4273985b70aSAmir Goldstein return this; 4283985b70aSAmir Goldstein 4293985b70aSAmir Goldstein fail: 4301bd0a3aeSlijiazi pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n", 4313985b70aSAmir Goldstein real, layer->idx, connected, err); 4323985b70aSAmir Goldstein this = ERR_PTR(err); 4333985b70aSAmir Goldstein goto out; 4343985b70aSAmir Goldstein } 4353985b70aSAmir Goldstein 43606170154SAmir Goldstein static struct dentry *ovl_lookup_real(struct super_block *sb, 43706170154SAmir Goldstein struct dentry *real, 43813464165SMiklos Szeredi const struct ovl_layer *layer); 43906170154SAmir Goldstein 4403985b70aSAmir Goldstein /* 4414b91c30aSAmir Goldstein * Lookup an indexed or hashed overlay dentry by real inode. 4424b91c30aSAmir Goldstein */ 4434b91c30aSAmir Goldstein static struct dentry *ovl_lookup_real_inode(struct super_block *sb, 4444b91c30aSAmir Goldstein struct dentry *real, 44513464165SMiklos Szeredi const struct ovl_layer *layer) 4464b91c30aSAmir Goldstein { 447*f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 44806170154SAmir Goldstein struct dentry *index = NULL; 4494b91c30aSAmir Goldstein struct dentry *this = NULL; 4504b91c30aSAmir Goldstein struct inode *inode; 4514b91c30aSAmir Goldstein 45206170154SAmir Goldstein /* 45306170154SAmir Goldstein * Decoding upper dir from index is expensive, so first try to lookup 45406170154SAmir Goldstein * overlay dentry in inode/dcache. 45506170154SAmir Goldstein */ 4564b91c30aSAmir Goldstein inode = ovl_lookup_inode(sb, real, !layer->idx); 4574b91c30aSAmir Goldstein if (IS_ERR(inode)) 4584b91c30aSAmir Goldstein return ERR_CAST(inode); 4594b91c30aSAmir Goldstein if (inode) { 4604b91c30aSAmir Goldstein this = d_find_any_alias(inode); 4614b91c30aSAmir Goldstein iput(inode); 4624b91c30aSAmir Goldstein } 4634b91c30aSAmir Goldstein 46406170154SAmir Goldstein /* 46506170154SAmir Goldstein * For decoded lower dir file handle, lookup index by origin to check 46606170154SAmir Goldstein * if lower dir was copied up and and/or removed. 46706170154SAmir Goldstein */ 46806170154SAmir Goldstein if (!this && layer->idx && ofs->indexdir && !WARN_ON(!d_is_dir(real))) { 46906170154SAmir Goldstein index = ovl_lookup_index(ofs, NULL, real, false); 47006170154SAmir Goldstein if (IS_ERR(index)) 47106170154SAmir Goldstein return index; 47206170154SAmir Goldstein } 47306170154SAmir Goldstein 47406170154SAmir Goldstein /* Get connected upper overlay dir from index */ 47506170154SAmir Goldstein if (index) { 4768ea28765SAmir Goldstein struct dentry *upper = ovl_index_upper(ofs, index, true); 47706170154SAmir Goldstein 47806170154SAmir Goldstein dput(index); 47906170154SAmir Goldstein if (IS_ERR_OR_NULL(upper)) 48006170154SAmir Goldstein return upper; 48106170154SAmir Goldstein 48206170154SAmir Goldstein /* 48306170154SAmir Goldstein * ovl_lookup_real() in lower layer may call recursively once to 48406170154SAmir Goldstein * ovl_lookup_real() in upper layer. The first level call walks 48506170154SAmir Goldstein * back lower parents to the topmost indexed parent. The second 48606170154SAmir Goldstein * recursive call walks back from indexed upper to the topmost 48706170154SAmir Goldstein * connected/hashed upper parent (or up to root). 48806170154SAmir Goldstein */ 48994375f9dSAmir Goldstein this = ovl_lookup_real(sb, upper, &ofs->layers[0]); 49006170154SAmir Goldstein dput(upper); 49106170154SAmir Goldstein } 49206170154SAmir Goldstein 4937168179fSAmir Goldstein if (IS_ERR_OR_NULL(this)) 4947168179fSAmir Goldstein return this; 4954b91c30aSAmir Goldstein 496124c2de2SAmir Goldstein if (ovl_dentry_real_at(this, layer->idx) != real) { 4974b91c30aSAmir Goldstein dput(this); 4984b91c30aSAmir Goldstein this = ERR_PTR(-EIO); 4994b91c30aSAmir Goldstein } 5004b91c30aSAmir Goldstein 5014b91c30aSAmir Goldstein return this; 5024b91c30aSAmir Goldstein } 5034b91c30aSAmir Goldstein 5044b91c30aSAmir Goldstein /* 5054b91c30aSAmir Goldstein * Lookup an indexed or hashed overlay dentry, whose real dentry is an 5064b91c30aSAmir Goldstein * ancestor of @real. 5074b91c30aSAmir Goldstein */ 5084b91c30aSAmir Goldstein static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb, 5094b91c30aSAmir Goldstein struct dentry *real, 51013464165SMiklos Szeredi const struct ovl_layer *layer) 5114b91c30aSAmir Goldstein { 5124b91c30aSAmir Goldstein struct dentry *next, *parent = NULL; 5134b91c30aSAmir Goldstein struct dentry *ancestor = ERR_PTR(-EIO); 5144b91c30aSAmir Goldstein 5154b91c30aSAmir Goldstein if (real == layer->mnt->mnt_root) 5164b91c30aSAmir Goldstein return dget(sb->s_root); 5174b91c30aSAmir Goldstein 5184b91c30aSAmir Goldstein /* Find the topmost indexed or hashed ancestor */ 5194b91c30aSAmir Goldstein next = dget(real); 5204b91c30aSAmir Goldstein for (;;) { 5214b91c30aSAmir Goldstein parent = dget_parent(next); 5224b91c30aSAmir Goldstein 5234b91c30aSAmir Goldstein /* 5244b91c30aSAmir Goldstein * Lookup a matching overlay dentry in inode/dentry 5254b91c30aSAmir Goldstein * cache or in index by real inode. 5264b91c30aSAmir Goldstein */ 5274b91c30aSAmir Goldstein ancestor = ovl_lookup_real_inode(sb, next, layer); 5284b91c30aSAmir Goldstein if (ancestor) 5294b91c30aSAmir Goldstein break; 5304b91c30aSAmir Goldstein 5314b91c30aSAmir Goldstein if (parent == layer->mnt->mnt_root) { 5324b91c30aSAmir Goldstein ancestor = dget(sb->s_root); 5334b91c30aSAmir Goldstein break; 5344b91c30aSAmir Goldstein } 5354b91c30aSAmir Goldstein 5364b91c30aSAmir Goldstein /* 5374b91c30aSAmir Goldstein * If @real has been moved out of the layer root directory, 5384b91c30aSAmir Goldstein * we will eventully hit the real fs root. This cannot happen 5394b91c30aSAmir Goldstein * by legit overlay rename, so we return error in that case. 5404b91c30aSAmir Goldstein */ 5414b91c30aSAmir Goldstein if (parent == next) { 5424b91c30aSAmir Goldstein ancestor = ERR_PTR(-EXDEV); 5434b91c30aSAmir Goldstein break; 5444b91c30aSAmir Goldstein } 5454b91c30aSAmir Goldstein 5464b91c30aSAmir Goldstein dput(next); 5474b91c30aSAmir Goldstein next = parent; 5484b91c30aSAmir Goldstein } 5494b91c30aSAmir Goldstein 5504b91c30aSAmir Goldstein dput(parent); 5514b91c30aSAmir Goldstein dput(next); 5524b91c30aSAmir Goldstein 5534b91c30aSAmir Goldstein return ancestor; 5544b91c30aSAmir Goldstein } 5554b91c30aSAmir Goldstein 5564b91c30aSAmir Goldstein /* 5573985b70aSAmir Goldstein * Lookup a connected overlay dentry whose real dentry is @real. 5583985b70aSAmir Goldstein * If @real is on upper layer, we lookup a child overlay dentry with the same 5593985b70aSAmir Goldstein * path the real dentry. Otherwise, we need to consult index for lookup. 5603985b70aSAmir Goldstein */ 5613985b70aSAmir Goldstein static struct dentry *ovl_lookup_real(struct super_block *sb, 5623985b70aSAmir Goldstein struct dentry *real, 56313464165SMiklos Szeredi const struct ovl_layer *layer) 5643985b70aSAmir Goldstein { 5653985b70aSAmir Goldstein struct dentry *connected; 5663985b70aSAmir Goldstein int err = 0; 5673985b70aSAmir Goldstein 5684b91c30aSAmir Goldstein connected = ovl_lookup_real_ancestor(sb, real, layer); 5694b91c30aSAmir Goldstein if (IS_ERR(connected)) 5704b91c30aSAmir Goldstein return connected; 5713985b70aSAmir Goldstein 5723985b70aSAmir Goldstein while (!err) { 5733985b70aSAmir Goldstein struct dentry *next, *this; 5743985b70aSAmir Goldstein struct dentry *parent = NULL; 57598892516SAmir Goldstein struct dentry *real_connected = ovl_dentry_real_at(connected, 57698892516SAmir Goldstein layer->idx); 5773985b70aSAmir Goldstein 5783985b70aSAmir Goldstein if (real_connected == real) 5793985b70aSAmir Goldstein break; 5803985b70aSAmir Goldstein 5813985b70aSAmir Goldstein /* Find the topmost dentry not yet connected */ 5823985b70aSAmir Goldstein next = dget(real); 5833985b70aSAmir Goldstein for (;;) { 5843985b70aSAmir Goldstein parent = dget_parent(next); 5853985b70aSAmir Goldstein 5863985b70aSAmir Goldstein if (parent == real_connected) 5873985b70aSAmir Goldstein break; 5883985b70aSAmir Goldstein 5893985b70aSAmir Goldstein /* 5903985b70aSAmir Goldstein * If real has been moved out of 'real_connected', 5913985b70aSAmir Goldstein * we will not find 'real_connected' and hit the layer 5923985b70aSAmir Goldstein * root. In that case, we need to restart connecting. 5933985b70aSAmir Goldstein * This game can go on forever in the worst case. We 5943985b70aSAmir Goldstein * may want to consider taking s_vfs_rename_mutex if 5953985b70aSAmir Goldstein * this happens more than once. 5963985b70aSAmir Goldstein */ 5973985b70aSAmir Goldstein if (parent == layer->mnt->mnt_root) { 5983985b70aSAmir Goldstein dput(connected); 5993985b70aSAmir Goldstein connected = dget(sb->s_root); 6003985b70aSAmir Goldstein break; 6013985b70aSAmir Goldstein } 6023985b70aSAmir Goldstein 6033985b70aSAmir Goldstein /* 6043985b70aSAmir Goldstein * If real file has been moved out of the layer root 6053985b70aSAmir Goldstein * directory, we will eventully hit the real fs root. 6063985b70aSAmir Goldstein * This cannot happen by legit overlay rename, so we 6073985b70aSAmir Goldstein * return error in that case. 6083985b70aSAmir Goldstein */ 6093985b70aSAmir Goldstein if (parent == next) { 6103985b70aSAmir Goldstein err = -EXDEV; 6113985b70aSAmir Goldstein break; 6123985b70aSAmir Goldstein } 6133985b70aSAmir Goldstein 6143985b70aSAmir Goldstein dput(next); 6153985b70aSAmir Goldstein next = parent; 6163985b70aSAmir Goldstein } 6173985b70aSAmir Goldstein 6183985b70aSAmir Goldstein if (!err) { 6193985b70aSAmir Goldstein this = ovl_lookup_real_one(connected, next, layer); 6203985b70aSAmir Goldstein if (IS_ERR(this)) 6213985b70aSAmir Goldstein err = PTR_ERR(this); 6223985b70aSAmir Goldstein 6233985b70aSAmir Goldstein /* 6243985b70aSAmir Goldstein * Lookup of child in overlay can fail when racing with 6253985b70aSAmir Goldstein * overlay rename of child away from 'connected' parent. 6263985b70aSAmir Goldstein * In this case, we need to restart the lookup from the 6273985b70aSAmir Goldstein * top, because we cannot trust that 'real_connected' is 6284b91c30aSAmir Goldstein * still an ancestor of 'real'. There is a good chance 6294b91c30aSAmir Goldstein * that the renamed overlay ancestor is now in cache, so 6304b91c30aSAmir Goldstein * ovl_lookup_real_ancestor() will find it and we can 6314b91c30aSAmir Goldstein * continue to connect exactly from where lookup failed. 6323985b70aSAmir Goldstein */ 6333985b70aSAmir Goldstein if (err == -ECHILD) { 6344b91c30aSAmir Goldstein this = ovl_lookup_real_ancestor(sb, real, 6354b91c30aSAmir Goldstein layer); 636b5095f24SFengguang Wu err = PTR_ERR_OR_ZERO(this); 6373985b70aSAmir Goldstein } 6383985b70aSAmir Goldstein if (!err) { 6393985b70aSAmir Goldstein dput(connected); 6403985b70aSAmir Goldstein connected = this; 6413985b70aSAmir Goldstein } 6423985b70aSAmir Goldstein } 6433985b70aSAmir Goldstein 6443985b70aSAmir Goldstein dput(parent); 6453985b70aSAmir Goldstein dput(next); 6463985b70aSAmir Goldstein } 6473985b70aSAmir Goldstein 6483985b70aSAmir Goldstein if (err) 6493985b70aSAmir Goldstein goto fail; 6503985b70aSAmir Goldstein 6513985b70aSAmir Goldstein return connected; 6523985b70aSAmir Goldstein 6533985b70aSAmir Goldstein fail: 6541bd0a3aeSlijiazi pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n", 6553985b70aSAmir Goldstein real, layer->idx, connected, err); 6563985b70aSAmir Goldstein dput(connected); 6573985b70aSAmir Goldstein return ERR_PTR(err); 6583985b70aSAmir Goldstein } 6593985b70aSAmir Goldstein 6603985b70aSAmir Goldstein /* 661f71bd9cfSAmir Goldstein * Get an overlay dentry from upper/lower real dentries and index. 6623985b70aSAmir Goldstein */ 6633985b70aSAmir Goldstein static struct dentry *ovl_get_dentry(struct super_block *sb, 6643985b70aSAmir Goldstein struct dentry *upper, 665f71bd9cfSAmir Goldstein struct ovl_path *lowerpath, 666f71bd9cfSAmir Goldstein struct dentry *index) 6673985b70aSAmir Goldstein { 668*f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 66913464165SMiklos Szeredi const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer; 670f71bd9cfSAmir Goldstein struct dentry *real = upper ?: (index ?: lowerpath->dentry); 6713985b70aSAmir Goldstein 672f941866fSAmir Goldstein /* 673f71bd9cfSAmir Goldstein * Obtain a disconnected overlay dentry from a non-dir real dentry 674f71bd9cfSAmir Goldstein * and index. 675f941866fSAmir Goldstein */ 676f71bd9cfSAmir Goldstein if (!d_is_dir(real)) 677f71bd9cfSAmir Goldstein return ovl_obtain_alias(sb, upper, lowerpath, index); 678f941866fSAmir Goldstein 6793985b70aSAmir Goldstein /* Removed empty directory? */ 68098892516SAmir Goldstein if ((real->d_flags & DCACHE_DISCONNECTED) || d_unhashed(real)) 6813985b70aSAmir Goldstein return ERR_PTR(-ENOENT); 6823985b70aSAmir Goldstein 6833985b70aSAmir Goldstein /* 68498892516SAmir Goldstein * If real dentry is connected and hashed, get a connected overlay 68598892516SAmir Goldstein * dentry whose real dentry is @real. 6863985b70aSAmir Goldstein */ 68798892516SAmir Goldstein return ovl_lookup_real(sb, real, layer); 6883985b70aSAmir Goldstein } 6893985b70aSAmir Goldstein 6908556a420SAmir Goldstein static struct dentry *ovl_upper_fh_to_d(struct super_block *sb, 6918556a420SAmir Goldstein struct ovl_fh *fh) 6928556a420SAmir Goldstein { 693*f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 6948556a420SAmir Goldstein struct dentry *dentry; 6958556a420SAmir Goldstein struct dentry *upper; 6968556a420SAmir Goldstein 69708f4c7c8SMiklos Szeredi if (!ovl_upper_mnt(ofs)) 6988556a420SAmir Goldstein return ERR_PTR(-EACCES); 6998556a420SAmir Goldstein 7001cdb0cb6SPavel Tikhomirov upper = ovl_decode_real_fh(ofs, fh, ovl_upper_mnt(ofs), true); 7018556a420SAmir Goldstein if (IS_ERR_OR_NULL(upper)) 7028556a420SAmir Goldstein return upper; 7038556a420SAmir Goldstein 704f71bd9cfSAmir Goldstein dentry = ovl_get_dentry(sb, upper, NULL, NULL); 7058556a420SAmir Goldstein dput(upper); 7068556a420SAmir Goldstein 7078556a420SAmir Goldstein return dentry; 7088556a420SAmir Goldstein } 7098556a420SAmir Goldstein 710f941866fSAmir Goldstein static struct dentry *ovl_lower_fh_to_d(struct super_block *sb, 711f941866fSAmir Goldstein struct ovl_fh *fh) 712f941866fSAmir Goldstein { 713*f01d0889SAndrea Righi struct ovl_fs *ofs = OVL_FS(sb); 714f941866fSAmir Goldstein struct ovl_path origin = { }; 715f941866fSAmir Goldstein struct ovl_path *stack = &origin; 716f941866fSAmir Goldstein struct dentry *dentry = NULL; 717f71bd9cfSAmir Goldstein struct dentry *index = NULL; 7188b58924aSAmir Goldstein struct inode *inode; 719f941866fSAmir Goldstein int err; 720f941866fSAmir Goldstein 7218b58924aSAmir Goldstein /* First lookup overlay inode in inode cache by origin fh */ 7228b58924aSAmir Goldstein err = ovl_check_origin_fh(ofs, fh, false, NULL, &stack); 7238b58924aSAmir Goldstein if (err) 7248b58924aSAmir Goldstein return ERR_PTR(err); 7258b58924aSAmir Goldstein 7268b58924aSAmir Goldstein if (!d_is_dir(origin.dentry) || 7278b58924aSAmir Goldstein !(origin.dentry->d_flags & DCACHE_DISCONNECTED)) { 7288b58924aSAmir Goldstein inode = ovl_lookup_inode(sb, origin.dentry, false); 7298b58924aSAmir Goldstein err = PTR_ERR(inode); 7308b58924aSAmir Goldstein if (IS_ERR(inode)) 7318b58924aSAmir Goldstein goto out_err; 7328b58924aSAmir Goldstein if (inode) { 7338b58924aSAmir Goldstein dentry = d_find_any_alias(inode); 7348b58924aSAmir Goldstein iput(inode); 7358b58924aSAmir Goldstein if (dentry) 7368b58924aSAmir Goldstein goto out; 7378b58924aSAmir Goldstein } 7388b58924aSAmir Goldstein } 7398b58924aSAmir Goldstein 7408b58924aSAmir Goldstein /* Then lookup indexed upper/whiteout by origin fh */ 741f71bd9cfSAmir Goldstein if (ofs->indexdir) { 742f71bd9cfSAmir Goldstein index = ovl_get_index_fh(ofs, fh); 743f71bd9cfSAmir Goldstein err = PTR_ERR(index); 7449436a1a3SAmir Goldstein if (IS_ERR(index)) { 7459436a1a3SAmir Goldstein index = NULL; 7468b58924aSAmir Goldstein goto out_err; 7479436a1a3SAmir Goldstein } 748f71bd9cfSAmir Goldstein } 749f941866fSAmir Goldstein 7508b58924aSAmir Goldstein /* Then try to get a connected upper dir by index */ 7513b0bfc6eSAmir Goldstein if (index && d_is_dir(index)) { 7528ea28765SAmir Goldstein struct dentry *upper = ovl_index_upper(ofs, index, true); 7533b0bfc6eSAmir Goldstein 7543b0bfc6eSAmir Goldstein err = PTR_ERR(upper); 7553b0bfc6eSAmir Goldstein if (IS_ERR_OR_NULL(upper)) 7563b0bfc6eSAmir Goldstein goto out_err; 7573b0bfc6eSAmir Goldstein 7583b0bfc6eSAmir Goldstein dentry = ovl_get_dentry(sb, upper, NULL, NULL); 7593b0bfc6eSAmir Goldstein dput(upper); 7603b0bfc6eSAmir Goldstein goto out; 7613b0bfc6eSAmir Goldstein } 7623b0bfc6eSAmir Goldstein 763155b8a04SAmir Goldstein /* Find origin.dentry again with ovl_acceptable() layer check */ 764155b8a04SAmir Goldstein if (d_is_dir(origin.dentry)) { 7658b58924aSAmir Goldstein dput(origin.dentry); 7668b58924aSAmir Goldstein origin.dentry = NULL; 7678a22efa1SAmir Goldstein err = ovl_check_origin_fh(ofs, fh, true, NULL, &stack); 7688b58924aSAmir Goldstein if (err) 769f71bd9cfSAmir Goldstein goto out_err; 7708b58924aSAmir Goldstein } 7718b58924aSAmir Goldstein if (index) { 772610afc0bSMiklos Szeredi err = ovl_verify_origin(ofs, index, origin.dentry, false); 773f71bd9cfSAmir Goldstein if (err) 774f71bd9cfSAmir Goldstein goto out_err; 775f71bd9cfSAmir Goldstein } 776f71bd9cfSAmir Goldstein 777155b8a04SAmir Goldstein /* Get a connected non-upper dir or disconnected non-dir */ 778f71bd9cfSAmir Goldstein dentry = ovl_get_dentry(sb, NULL, &origin, index); 779f71bd9cfSAmir Goldstein 780f71bd9cfSAmir Goldstein out: 781f941866fSAmir Goldstein dput(origin.dentry); 782f71bd9cfSAmir Goldstein dput(index); 783f941866fSAmir Goldstein return dentry; 784f71bd9cfSAmir Goldstein 785f71bd9cfSAmir Goldstein out_err: 786f71bd9cfSAmir Goldstein dentry = ERR_PTR(err); 787f71bd9cfSAmir Goldstein goto out; 788f941866fSAmir Goldstein } 789f941866fSAmir Goldstein 790cbe7fba8SAmir Goldstein static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type) 791cbe7fba8SAmir Goldstein { 792cbe7fba8SAmir Goldstein struct ovl_fh *fh; 793cbe7fba8SAmir Goldstein 794cbe7fba8SAmir Goldstein /* If on-wire inner fid is aligned - nothing to do */ 795cbe7fba8SAmir Goldstein if (fh_type == OVL_FILEID_V1) 796cbe7fba8SAmir Goldstein return (struct ovl_fh *)fid; 797cbe7fba8SAmir Goldstein 798cbe7fba8SAmir Goldstein if (fh_type != OVL_FILEID_V0) 799cbe7fba8SAmir Goldstein return ERR_PTR(-EINVAL); 800cbe7fba8SAmir Goldstein 8019aafc1b0SDan Carpenter if (buflen <= OVL_FH_WIRE_OFFSET) 8029aafc1b0SDan Carpenter return ERR_PTR(-EINVAL); 8039aafc1b0SDan Carpenter 804cbe7fba8SAmir Goldstein fh = kzalloc(buflen, GFP_KERNEL); 805cbe7fba8SAmir Goldstein if (!fh) 806cbe7fba8SAmir Goldstein return ERR_PTR(-ENOMEM); 807cbe7fba8SAmir Goldstein 808cbe7fba8SAmir Goldstein /* Copy unaligned inner fh into aligned buffer */ 809cf8aa9bfSKees Cook memcpy(fh->buf, fid, buflen - OVL_FH_WIRE_OFFSET); 810cbe7fba8SAmir Goldstein return fh; 811cbe7fba8SAmir Goldstein } 812cbe7fba8SAmir Goldstein 8138556a420SAmir Goldstein static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid, 8148556a420SAmir Goldstein int fh_len, int fh_type) 8158556a420SAmir Goldstein { 8168556a420SAmir Goldstein struct dentry *dentry = NULL; 817cbe7fba8SAmir Goldstein struct ovl_fh *fh = NULL; 8188556a420SAmir Goldstein int len = fh_len << 2; 8198556a420SAmir Goldstein unsigned int flags = 0; 8208556a420SAmir Goldstein int err; 8218556a420SAmir Goldstein 822cbe7fba8SAmir Goldstein fh = ovl_fid_to_fh(fid, len, fh_type); 823cbe7fba8SAmir Goldstein err = PTR_ERR(fh); 824cbe7fba8SAmir Goldstein if (IS_ERR(fh)) 8258556a420SAmir Goldstein goto out_err; 8268556a420SAmir Goldstein 8278556a420SAmir Goldstein err = ovl_check_fh_len(fh, len); 8288556a420SAmir Goldstein if (err) 8298556a420SAmir Goldstein goto out_err; 8308556a420SAmir Goldstein 831cbe7fba8SAmir Goldstein flags = fh->fb.flags; 832f941866fSAmir Goldstein dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ? 833f941866fSAmir Goldstein ovl_upper_fh_to_d(sb, fh) : 834f941866fSAmir Goldstein ovl_lower_fh_to_d(sb, fh); 8358556a420SAmir Goldstein err = PTR_ERR(dentry); 8368556a420SAmir Goldstein if (IS_ERR(dentry) && err != -ESTALE) 8378556a420SAmir Goldstein goto out_err; 8388556a420SAmir Goldstein 839cbe7fba8SAmir Goldstein out: 840cbe7fba8SAmir Goldstein /* We may have needed to re-align OVL_FILEID_V0 */ 841cbe7fba8SAmir Goldstein if (!IS_ERR_OR_NULL(fh) && fh != (void *)fid) 842cbe7fba8SAmir Goldstein kfree(fh); 843cbe7fba8SAmir Goldstein 8448556a420SAmir Goldstein return dentry; 8458556a420SAmir Goldstein 8468556a420SAmir Goldstein out_err: 8471bd0a3aeSlijiazi pr_warn_ratelimited("failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n", 848cbe7fba8SAmir Goldstein fh_len, fh_type, flags, err); 849cbe7fba8SAmir Goldstein dentry = ERR_PTR(err); 850cbe7fba8SAmir Goldstein goto out; 8518556a420SAmir Goldstein } 8528556a420SAmir Goldstein 8533985b70aSAmir Goldstein static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid, 8543985b70aSAmir Goldstein int fh_len, int fh_type) 8553985b70aSAmir Goldstein { 8561bd0a3aeSlijiazi pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n"); 8573985b70aSAmir Goldstein return ERR_PTR(-EACCES); 8583985b70aSAmir Goldstein } 8593985b70aSAmir Goldstein 8603985b70aSAmir Goldstein static int ovl_get_name(struct dentry *parent, char *name, 8613985b70aSAmir Goldstein struct dentry *child) 8623985b70aSAmir Goldstein { 8633985b70aSAmir Goldstein /* 8643985b70aSAmir Goldstein * ovl_fh_to_dentry() returns connected dir overlay dentries and 8653985b70aSAmir Goldstein * ovl_fh_to_parent() is not implemented, so we should not get here. 8663985b70aSAmir Goldstein */ 8673985b70aSAmir Goldstein WARN_ON_ONCE(1); 8683985b70aSAmir Goldstein return -EIO; 8693985b70aSAmir Goldstein } 8703985b70aSAmir Goldstein 8713985b70aSAmir Goldstein static struct dentry *ovl_get_parent(struct dentry *dentry) 8723985b70aSAmir Goldstein { 8733985b70aSAmir Goldstein /* 8743985b70aSAmir Goldstein * ovl_fh_to_dentry() returns connected dir overlay dentries, so we 8753985b70aSAmir Goldstein * should not get here. 8763985b70aSAmir Goldstein */ 8773985b70aSAmir Goldstein WARN_ON_ONCE(1); 8783985b70aSAmir Goldstein return ERR_PTR(-EIO); 8793985b70aSAmir Goldstein } 8803985b70aSAmir Goldstein 8818ed5eec9SAmir Goldstein const struct export_operations ovl_export_operations = { 8825b2cccd3SAmir Goldstein .encode_fh = ovl_encode_fh, 8838556a420SAmir Goldstein .fh_to_dentry = ovl_fh_to_dentry, 8843985b70aSAmir Goldstein .fh_to_parent = ovl_fh_to_parent, 8853985b70aSAmir Goldstein .get_name = ovl_get_name, 8863985b70aSAmir Goldstein .get_parent = ovl_get_parent, 8878ed5eec9SAmir Goldstein }; 88816aac5adSAmir Goldstein 88916aac5adSAmir Goldstein /* encode_fh() encodes non-decodable file handles with nfs_export=off */ 89016aac5adSAmir Goldstein const struct export_operations ovl_export_fid_operations = { 89116aac5adSAmir Goldstein .encode_fh = ovl_encode_fh, 89216aac5adSAmir Goldstein }; 893