Overlayfs lazy lookup of lowerdata
Subsystems (2)
Amir Goldstein
maintainercover Overlayfs lazy lookup of lowerdata
Miklos,
Here are the patches discussed earlier at [1]. They are based on the already posted cleanup series [2].
This work is motivated by Alexander's composefs use case. Alexander has been developing and testing his fsverity patches over my lazy-lowerdata-lookup branch [3].
Alexander has also written tests for lazy lowerdata lookup [4].
Thanks,
Amir.
[1] https://lore.kernel.org/linux-unionfs/CAOQ4uxich227fP7bGSCNqx-JX5h36O-MLwqPoy0r33tuH=z2cA@mail.gmail.com/
[2] https://lore.kernel.org/linux-unionfs/[email protected]/
[3] https://github.com/amir73il/linux/commits/ovl-lazy-lowerdata
[4] https://github.com/amir73il/xfstests/commits/ovl-lazy-lowerdata
Amir Goldstein (5):
ovl: remove unneeded goto instructions
ovl: introduce data-only lower layers
ovl: implement lookup in data-only layers
ovl: prepare for lazy lookup of lowerdata inode
ovl: implement lazy lookup of lowerdata in data-only layers
Documentation/filesystems/overlayfs.rst | 32 +++++++ fs/overlayfs/copy_up.c | 9 ++ fs/overlayfs/export.c | 2 +- fs/overlayfs/file.c | 21 +++- fs/overlayfs/inode.c | 18 +++- fs/overlayfs/namei.c | 121 +++++++++++++++++++++++- fs/overlayfs/overlayfs.h | 2 + fs/overlayfs/ovl_entry.h | 11 ++- fs/overlayfs/super.c | 68 +++++++++---- fs/overlayfs/util.c | 33 ++++++- 10 files changed, 286 insertions(+), 31 deletions(-)
Signature · 1 line
2.34.1
Amir Goldstein
maintainerPATCH 1/5 ovl: remove unneeded goto instructions
There is nothing in the out goto target of ovl_get_layers().
--- fs/overlayfs/super.c | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-)
fs/overlayfs/super.c +9 -12
@@ -1586,10 +1586,9 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,int err;unsigned int i; - err = -ENOMEM ; ofs->fs =kcalloc (numlower +1 ,sizeof (struct ovl_sb ),GFP_KERNEL );if (ofs->fs ==NULL ) - goto out; +return -ENOMEM ;/* idx/fsid 0 are reserved for upper fs even with lower only overlay */ ofs->numfs++;
@@ -1603,7 +1602,7 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, err =get_anon_bdev (&ofs->fs[0 ].pseudo_dev);if (err) {pr_err ("failed to get anonymous bdev for upper fs\n" ); - goto out; +return err; }if (ovl_upper_mnt (ofs)) {
@@ -1616,9 +1615,9 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,struct inode *trap;int fsid; - err = fsid =ovl_get_fsid (ofs, &stack[i]); -if (err <0 ) - goto out; + fsid =ovl_get_fsid (ofs, &stack[i]); +if (fsid <0 ) +return fsid;/* * Check if lower root conflicts with this overlay layers before
@@ -1629,13 +1628,13 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,*/ err =ovl_setup_trap (sb, stack[i].dentry, &trap,"lowerdir" );if (err) - goto out; +return err;if (ovl_is_inuse (stack[i].dentry)) { err =ovl_report_in_use (ofs,"lowerdir" );if (err) {iput (trap); - goto out; +return err; } }
@@ -1644,7 +1643,7 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,if (IS_ERR (mnt)) {pr_err ("failed to clone lowerpath\n" );iput (trap); - goto out; +return err; }/*
@@ -1694,9 +1693,7 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, ofs->xino_mode); } - err =0 ; -out: -return err; +return 0 ; } static int ovl_get_lowerstack(struct super_block *sb, struct ovl_entry *oe,
Signature · 1 line
2.34.1
Re: [PATCH 1/5] ovl: remove unneeded goto instructions
Quoted 3 lines · Amir Goldstein
There is nothing in the out goto target of
ovl_get_layers().Signed-off-by Amir Goldstein <[email protected]>
LGTM
Quoted 90 lines
---
fs/overlayfs/super.c | 21 +++++++++------------1 file changed, 9 insertions(+), 12 deletions(-)fs/overlayfs/super.c +0
-0@@ -1586,10 +1586,9 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, int err; unsigned int i;
- err =-ENOMEM;
ofs->fs =kcalloc(numlower + 1, sizeof(struct ovl_sb), GFP_KERNEL);
if (ofs->fs== NULL)
- goto out;
+ return-ENOMEM;
/* idx/fsid 0 are reserved for upper fs even with lower only overlay */
ofs->numfs++;fs/overlayfs/super.c +0
-0@@ -1603,7 +1602,7 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, err = get_anon_bdev(&ofs->fs[0].pseudo_dev); if (err) {pr_err("failed to get anonymous bdev for upper fs\n");
- goto out;
+ return err;
}
if (ovl_upper_mnt(ofs)) {fs/overlayfs/super.c +0
-0@@ -1616,9 +1615,9 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, struct inode *trap; int fsid;
- err = fsid =ovl_get_fsid(ofs, &stack[i]); - if (err < 0)
- goto out;
+ fsid =ovl_get_fsid(ofs, &stack[i]);
+ if (fsid < 0)
+ return fsid;
/*
* Check if lower root conflicts with this overlay layers beforefs/overlayfs/super.c +1
-1@@ -1629,13 +1628,13 @@ static int ovl_get_layers(struct super_block*sb, struct ovl_fs *ofs, */ err = ovl_setup_trap(sb, stack[i].dentry, &trap,"lowerdir" ); if (err) - goto out; + return err;
if (ovl_is_inuse(stack[i].dentry)) { err =ovl_report_in_use(ofs, "lowerdir"); if (err) {
iput(trap);
- goto out;
+ return err;
}
}fs/overlayfs/super.c +1
-1@@ -1644,7 +1643,7 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, if (IS_ERR(mnt)) { pr_err("failed to clone lowerpath\n"); iput(trap); - goto out; + return err; }
/*fs/overlayfs/super.c +0
-0@@ -1694,9 +1693,7 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, ofs->xino_mode); }
- err = 0;
-out:
- return err;
+ return 0;
}
static int ovl_get_lowerstack(structsuper_block*sb, structovl_entry*oe,
Signature · 9 lines
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=-=
Alexander Larsson Red Hat,
Inc
[email protected] [email protected]
He's a maverick shark-wrestling romance novelist in a wheelchair. She's
a
manipulative nymphomaniac Hell's Angel with a birthmark shaped like
Liberty's torch. They fight crime! Amir Goldstein
maintainerPATCH 2/5 ovl: introduce data-only lower layers
In reply to Amir GoldsteinIntroduce the format lowerdir=lower1:lower2::lowerdata1:lowerdata2 where the lower layers after the :: separator are not merged into the overlayfs merge dirs.
The files in those layers are only meant to be accessible via absolute redirect from metacopy files in lower layers. Following changes will implement lookup in the data layers.
This feature was requested for composefs ostree use case, where the lower data layer should only be accessiable via absolute redirects from metacopy inodes.
The lower data layers are not required to a have a unique uuid or any uuid at all, because they are never used to compose the overlayfs inode st_ino/st_dev.
--- Documentation/filesystems/overlayfs.rst | 32 +++++++++++++++++ fs/overlayfs/namei.c | 4 +-- fs/overlayfs/ovl_entry.h | 9 +++++ fs/overlayfs/super.c | 46 +++++++++++++++++++++---- 4 files changed, 82 insertions(+), 9 deletions(-)
Documentation/filesystems/overlayfs.rst +32 -0
@@ -371,6 +371,38 @@ conflict with metacopy=on, and will result in an error. [*] redirect_dir=follow only conflicts with metacopy=on if upperdir=... is given. + +Data-only lower layers +---------------------- + +With "metacopy" feature enabled, an overlayfs regular file may be a composition +of information from up to three different layers: + + 1) metadata from a file in the upper layer + + 2) st_ino and st_dev object identifier from a file in a lower layer + + 3) data from a file in another lower layer (further below) + +The "lower data" file can be on any lower layer, except from the top most +lower layer. + +Below the top most lower layer, any number of lower most layers may be defined +as "data-only" lower layers, using the double collon ("::") separator. + +For example: + + mount -t overlay overlay -olowerdir=/lower1::/lower2:/lower3 /merged + +The paths of files in the "data-only" lower layers are not visible in the +merged overlayfs directories and the metadata and st_ino/st_dev of files +in the "data-only" lower layers are not visible in overlayfs inodes. + +Only the data of the files in the "data-only" lower layers may be visible +when a "metacopy" file in one of the lower layers above it, has a "redirect" +to the absolute path of the "lower data" file in the "data-only" lower layer. + + Sharing and copying layers --------------------------
fs/overlayfs/namei.c +2 -2
@@ -356,7 +356,7 @@ int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, bool connected,struct dentry *origin =NULL ;int i; -for (i =1 ; i < ofs->numlayer; i++) { +for (i =1 ; i <=ovl_numlowerlayer (ofs); i++) {/* * If lower fs uuid is not unique among lower fs we cannot match * fh->uuid to layer.
@@ -907,7 +907,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,if (!d.stop &&ovl_numlower (poe)) { err = -ENOMEM ; - stack =ovl_stack_alloc (ofs->numlayer -1 ); + stack =ovl_stack_alloc (ovl_numlowerlayer (ofs));if (!stack) goto out_put_upper; }
fs/overlayfs/ovl_entry.h +9 -0
@@ -62,6 +62,8 @@ struct ovl_fs {unsigned int numlayer;/* Number of unique fs among layers including upper fs */ unsigned int numfs; +/* Number of data-only lower layers */ +unsigned int numdatalayer;const struct ovl_layer *layers;struct ovl_sb *fs;/* workbasedir is the path at workdir= mount option */
@@ -95,6 +97,13 @@ struct ovl_fs {errseq_t errseq; }; + +/* Number of lower layers, not including data-only layers */ +static inline unsigned int ovl_numlowerlayer (struct ovl_fs *ofs) +{ +return ofs->numlayer - ofs->numdatalayer -1 ; +} +static inline struct vfsmount *ovl_upper_mnt (struct ovl_fs *ofs) {return ofs->layers[0 ].mnt;
fs/overlayfs/super.c +39 -7
94 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH 2/5] ovl: introduce data-only lower layers
Quoted 13 lines · Amir Goldstein
Introduce the format lowerdir=lower1:lower2::lowerdata1:lowerdata2 where the lower layers after the :: separator are not merged into the overlayfs merge dirs.
The files in those layers are only meant to be accessible via absolute
redirect from metacopy files in lower layers. Following changes will implement lookup in the data layers.This feature was requested for composefs ostree use case, where the lower data layer should only be accessiable via absolute redirects from metacopy inodes.
Quoted 6 lines
The lower data layers are not required to a have a unique uuid or any uuid at all, because they are never used to compose the overlayfs inode
st_ino/st_dev.Signed-off-by Amir Goldstein <[email protected]>
Quoted 38 lines
---
Documentation/filesystems/overlayfs.rst | 32 +++++++++++++++++ fs/overlayfs/namei.c | 4 +-- fs/overlayfs/ovl_entry.h | 9 +++++ fs/overlayfs/super.c | 46 +++++++++++++++++++++-- --4 files changed, 82 insertions(+), 9 deletions(-)Documentation/filesystems/overlayfs.rst +0
-0@@ -371,6 +371,38 @@ conflict with metacopy=on, and will result in anerror.
[*] redirect_dir=follow only conflicts with metacopy=on if upperdir=... is
given.Documentation/filesystems/overlayfs.rst +5
-0+ +Data-only lower layers +---------------------- + +With "metacopy" feature enabled, an overlayfs regular file may be acomposition
Documentation/filesystems/overlayfs.rst +9
-0+of information from up to three different layers: + + 1) metadata from a file in the upper layer + + 2) st_ino and st_dev object identifier from a file in a lower layer + + 3) data from a file in another lower layer (further below) + +The "lower data" file can be on any lower layer, except from the topmost
Documentation/filesystems/overlayfs.rst +3
-0+lower layer. + +Below the top most lower layer, any number of lower most layers may
Quoted 3 lines
be defined
+as "data-only" lower layers, using the double collon ("::") separator.
"colon", not "collon"
Quoted 40 lines
Documentation/filesystems/overlayfs.rst +4
-0+ +For example: + + mount -t overlay overlay -olowerdir=/lower1::/lower2:/lower3/merged
Documentation/filesystems/overlayfs.rst +2
-0+ +The paths of files in the "data-only" lower layers are not visiblein the
+merged overlayfs directories and the metadata and st_ino/st_dev of filesDocumentation/filesystems/overlayfs.rst +3
-0+in the "data-only" lower layers are not visible in overlayfs inodes. + +Only the data of the files in the "data-only" lower layers may bevisible
+when a "metacopy" file in one of the lower layers above it, has a "redirect"
+to the absolute path of the "lower data" file in the "data-only" lower layer.Documentation/filesystems/overlayfs.rst +2
-0+ +Sharing and copying layers
--------------------------fs/overlayfs/namei.c +0
-0@@ -356,7 +356,7 @@ int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, bool connected, struct dentry *origin = NULL; int i;
- for (i = 1; i <ofs->numlayer; i++) {
+ for (i = 1; i <=ovl_numlowerlayer(ofs); i++) { /*
* If lower fs uuid is not unique among lower fs we cannot match
*fh->uuidto layer.fs/overlayfs/namei.c +0
-0@@ -907,7 +907,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
Quoted 8 lines
if (!d.stop &&ovl_numlower(poe)) {
err =-ENOMEM;
- stack =ovl_stack_alloc(ofs->numlayer - 1); + stack = ovl_stack_alloc(ovl_numlowerlayer(ofs)); if (!stack)
gotoout_put_upper;
}
Again, surely ovl_numlower(poe) is a better size here?
Quoted 121 lines
fs/overlayfs/ovl_entry.h +2
-0@@ -62,6 +62,8 @@ struct ovl_fs { unsigned int numlayer; /* Number of unique fs among layers including upper fs */ unsigned int numfs; + /* Number of data-only lower layers */ + unsigned int numdatalayer; const struct ovl_layer *layers; struct ovl_sb *fs; /* workbasedir is the path at workdir= mount option */@@ -95,6 +97,13 @@ struct ovl_fs { errseq_t errseq; };fs/overlayfs/ovl_entry.h +7
-0+ +/* Number of lower layers, not including data-only layers */ +static inline unsigned int ovl_numlowerlayer (struct ovl_fs *ofs) +{ + return ofs->numlayer - ofs->numdatalayer - 1; +} +static inline struct vfsmount *ovl_upper_mnt(struct
ovl_fs*ofs) {
return ofs->layers[0].mnt;fs/overlayfs/super.c +0
-0@@ -1579,6 +1579,16 @@ static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path) return ofs->numfs++; }fs/overlayfs/super.c +10
-0+/* +* The fsid after the last lower fsid is used for the data layers. +* It is a "null fs" with a null sb, null uuid, and no pseudo dev. +*/ +static int ovl_get_data_fsid (struct ovl_fs *ofs) +{ + return ofs->numfs; +} + +static int ovl_get_layers(struct
super_block*sb, structovl_fs*ofs,
struct path *stack, unsigned int numlower, structovl_layer*layers)fs/overlayfs/super.c +0
-0@@ -1586,11 +1596,14 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, int err; unsigned int i;
- ofs->fs =kcalloc(numlower + 1, sizeof(struct ovl_sb), GFP_KERNEL);
+ ofs->fs =kcalloc(numlower + 2, sizeof(struct ovl_sb), GFP_KERNEL);
if (ofs->fs== NULL)
return-ENOMEM;
- /* idx/fsid 0 are reserved for upper fs even with lower only overlay */
+ /*
+ * idx/fsid 0 are reserved for upper fs even with lower only overlay
+ * and the last fsid is reserved for "null fs" of the data layers.
+ */
ofs->numfs++;
/*fs/overlayfs/super.c +0
-0@@ -1615,7 +1628,10 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, struct inode *trap; int fsid;
- fsid =ovl_get_fsid(ofs, &stack[i]); + if (i < numlower -ofs->numdatalayer) + fsid =ovl_get_fsid(ofs, &stack[i]); + else
+ fsid =ovl_get_data_fsid(ofs); if (fsid < 0)
return fsid;fs/overlayfs/super.c +1
-0@@ -1703,6 +1719,7 @@ static int ovl_get_lowerstack(struct super_block *sb, struct ovl_entry *oe, int err; struct path *stack = NULL; struct ovl_path *lowerstack; + unsigned int numlowerdata = 0; unsigned int i;
if (!ofs->config.upperdir && numlower == 1) {fs/overlayfs/super.c +0
-0@@ -1714,13 +1731,27 @@ static int ovl_get_lowerstack(struct super_block *sb, struct ovl_entry *oe, if (!stack) return -ENOMEM;
- err =-EINVAL;
- for (i = 0; i < numlower; i++) {
+ for (i = 0; i < numlower;) {
err = ovl_lower_dir(lower, &stack[i], ofs, &sb-Quoted 1 line
s_stack_depth);if (err)
gotoout_err;
lower =strchr(lower, '\0')+ 1;
+
+ i++;
+ err =-EINVAL;
+ /* :: seperator indicates the start of lower data layers */
+ if (!*lower && i < numlower && !numlowerdata) { + if (!ofs->config.metacopy) {
+ pr_err("lower data-only dirs require metacopy support.\n");
+ gotoout_err;
+ }
+ lower++;
Quoted 8 lines
+ numlower--;
+ ofs->numdatalayer = numlowerdata = numlower - i;
+ pr_info("using the lowest %d of %d lowerdirs as data layers\n",
+ numlowerdata, numlower);
+ }
}
This will handle a "::" at the end of the string as an error. Maybe it would be better to treat it as "zero lower data layera", to make code that generates mount options more regular? Not a huge issue though.
Quoted 18 lines
err =
-EINVAL;fs/overlayfs/super.c +0
-0@@ -1734,12 +1765,13 @@ static int ovl_get_lowerstack(struct super_block *sb, struct ovl_entry *oe, if (err) goto out_err;
- err =ovl_init_entry(oe, NULL, numlower);
+ /* Data-only layers are not merged in root directory */ + err =ovl_init_entry(oe, NULL, numlower - numlowerdata); if (err)
gotoout_err;
lowerstack =ovl_lowerstack(oe);
- for (i = 0; i < numlower; i++) {
+ for (i = 0; i < numlower - numlowerdata; i++) { lowerstack[i].dentry =dget(stack[i].dentry); lowerstack[i].layer = &ofs->layers[i+1]; }
Signature · 8 lines
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=-=
Alexander Larsson Red Hat,
Inc
[email protected] [email protected]
He's a one-legged native American master criminal on the edge. She's a
supernatural paranoid wrestler with someone else's memories. They fight
crime! Amir Goldstein
maintainerRe: [PATCH 2/5] ovl: introduce data-only lower layers
Quoted 109 lines · Alexander Larsson
Quoted 13 lines · Amir Goldstein
Introduce the format lowerdir=lower1:lower2::lowerdata1:lowerdata2 where the lower layers after the :: separator are not merged into the overlayfs merge dirs.
The files in those layers are only meant to be accessible via absolute
redirect from metacopy files in lower layers. Following changes will implement lookup in the data layers.This feature was requested for composefs ostree use case, where the lower data layer should only be accessiable via absolute redirects from metacopy inodes.
Quoted 6 lines
The lower data layers are not required to a have a unique uuid or any uuid at all, because they are never used to compose the overlayfs inode
st_ino/st_dev.Signed-off-by Amir Goldstein <[email protected]>Reviewed-by Alexander Larsson <[email protected]>Quoted 38 lines
--- Documentation/filesystems/overlayfs.rst | 32 +++++++++++++++++ fs/overlayfs/namei.c | 4 +-- fs/overlayfs/ovl_entry.h | 9 +++++ fs/overlayfs/super.c | 46 +++++++++++++++++++++-- -- 4 files changed, 82 insertions(+), 9 deletions(-)Documentation/filesystems/overlayfs.rst +0
-0@@ -371,6 +371,38 @@ conflict with metacopy=on, and will result in anerror.
[*] redirect_dir=follow only conflicts with metacopy=on if
upperdir=... is
given.Documentation/filesystems/overlayfs.rst +5
-0+ +Data-only lower layers +---------------------- + +With "metacopy" feature enabled, an overlayfs regular file may be acomposition
Documentation/filesystems/overlayfs.rst +9
-0+of information from up to three different layers: + + 1) metadata from a file in the upper layer + + 2) st_ino and st_dev object identifier from a file in a lower layer + + 3) data from a file in another lower layer (further below) + +The "lower data" file can be on any lower layer, except from the topmost
Documentation/filesystems/overlayfs.rst +3
-0+lower layer. + +Below the top most lower layer, any number of lower most layers mayQuoted 3 lines
be defined
+as "data-only" lower layers, using the double collon ("::") separator."colon", not "collon"
Quoted 41 lines
Documentation/filesystems/overlayfs.rst +4
-0+ +For example: + + mount -t overlay overlay -olowerdir=/lower1::/lower2:/lower3/merged
Documentation/filesystems/overlayfs.rst +2
-0+ +The paths of files in the "data-only" lower layers are not visiblein the
+merged overlayfs directories and the metadata and st_ino/st_dev of filesDocumentation/filesystems/overlayfs.rst +3
-0+in the "data-only" lower layers are not visible in overlayfs inodes. + +Only the data of the files in the "data-only" lower layers may bevisible
+when a "metacopy" file in one of the lower layers above it, has a "redirect"
+to the absolute path of the "lower data" file in the "data-only" lower layer.Documentation/filesystems/overlayfs.rst +2
-0+ + Sharing and copying layers --------------------------fs/overlayfs/namei.c +1
-1@@ -356,7 +356,7 @@ int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, bool connected, struct dentry *origin = NULL;int i; -for (i =1 ; i < ofs->numlayer; i++) { +for (i =1 ; i <=ovl_numlowerlayer (ofs); i++) {/* * If lower fs uuid is not unique among lower fs we cannot match
*fh->uuidto layer.fs/overlayfs/namei.c +0
-0@@ -907,7 +907,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
Quoted 9 lines
Quoted 7 lines
fs/overlayfs/namei.c +1
-1if (!d.stop &&ovl_numlower (poe)) { err = -ENOMEM ; - stack =ovl_stack_alloc (ofs->numlayer -1 ); + stack =ovl_stack_alloc (ovl_numlowerlayer (ofs));if (!stack) goto out_put_upper;}Again, surely
ovl_numlower(poe)is a better size here?
Intentional. that is changed in the following patch. (to ovl_numlowerlayer(ofs) + 1)
As the commit message says:
"Following changes will implement lookup in the data layers."
Quoted 131 lines
Quoted 127 lines
fs/overlayfs/ovl_entry.h +9
-0@@ -62,6 +62,8 @@ struct ovl_fs {unsigned int numlayer;/* Number of unique fs among layers including upper fs */ unsigned int numfs; +/* Number of data-only lower layers */ +unsigned int numdatalayer;const struct ovl_layer *layers;struct ovl_sb *fs;/* workbasedir is the path at workdir= mount option */ @@ -95,6 +97,13 @@ struct ovl_fs {errseq_t errseq; }; + +/* Number of lower layers, not including data-only layers */ +static inline unsigned int ovl_numlowerlayer (struct ovl_fs *ofs) +{ +return ofs->numlayer - ofs->numdatalayer -1 ; +} +static inline struct vfsmount *ovl_upper_mnt (struct ovl_fs *ofs) {return ofs->layers[0 ].mnt;fs/overlayfs/super.c +10
-0@@ -1579,6 +1579,16 @@ static int ovl_get_fsid(struct ovl_fs *ofs, const struct path *path)return ofs->numfs++; } +/* +* The fsid after the last lower fsid is used for the data layers. +* It is a "null fs" with a null sb, null uuid, and no pseudo dev. +*/ +static int ovl_get_data_fsid (struct ovl_fs *ofs) +{ +return ofs->numfs; +} + + static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs,struct path *stack, unsigned int numlower, struct
ovl_layer*layers)fs/overlayfs/super.c +1
-2@@ -1586,11 +1596,14 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, int err;unsigned int i; - ofs->fs =kcalloc (numlower +1 ,sizeof (struct ovl_sb ), GFP_KERNEL); + ofs->fs =kcalloc (numlower +2 ,sizeof (struct ovl_sb ),GFP_KERNEL );if (ofs->fs ==NULL )return -ENOMEM ; -/* idx/fsid 0 are reserved for upper fs even with lower only overlay */
fs/overlayfs/super.c +2
-0+/* +* idx/fsid 0 are reserved for upper fs even with lower only overlay
+ * and the last fsid is reserved for "null fs" of the data
layers.fs/overlayfs/super.c +6
-1+*/ ofs->numfs++;/* @@ -1615,7 +1628,10 @@ static int ovl_get_layers(struct super_block *sb, struct ovl_fs *ofs, struct inode *trap;int fsid; - fsid =ovl_get_fsid (ofs, &stack[i]); +if (i < numlower - ofs->numdatalayer) + fsid =ovl_get_fsid (ofs, &stack[i]); +else + fsid =ovl_get_data_fsid (ofs);if (fsid <0 )return fsid;@@ -1703,6 +1719,7 @@ static int ovl_get_lowerstack(struct super_block *sb, struct ovl_entry *oe, int err;struct path *stack =NULL ;struct ovl_path *lowerstack; +unsigned int numlowerdata =0 ;unsigned int i;if (!ofs->config.upperdir && numlower == 1) {fs/overlayfs/super.c +5
-2@@ -1714,13 +1731,27 @@ static int ovl_get_lowerstack(struct super_block *sb, struct ovl_entry *oe, if (!stack) return -ENOMEM; - err = -EINVAL ; -for (i =0 ; i < numlower; i++) { +for (i =0 ; i < numlower;) { err =ovl_lower_dir (lower, &stack[i], ofs, &sb- >s_stack_depth);if (err) goto out_err; lower =strchr (lower,'\0' ) +1 ; + + i++; + err = -EINVAL ; +/* :: seperator indicates the start of lower data layers */
fs/overlayfs/super.c +3
-0+if (!*lower && i < numlower && !numlowerdata) { +if (!ofs->config.metacopy) { + pr_err("lower data-only dirs requiremetacopy support.\n");
fs/overlayfs/super.c +5
-0+ goto out_err; + } + lower++; + numlower--; + ofs->numdatalayer = numlowerdata = numlower -i;
+ pr_info("using the lowest %d of %d lowerdirs
as data layers\n",fs/overlayfs/super.c static int ovl_get_lowerstack(struct super_block *sb, struct ovl_entry *oe, · line 1755
Quoted 3 lines
fs/overlayfs/super.c +2
-0+ numlowerdata, numlower); + } }
Quoted 4 lines
This will handle a "::" at the end of the string as an error. Maybe it would be better to treat it as "zero lower data layera", to make code that generates mount options more regular? Not a huge issue though.
No reason to do that.
Code that prepares lowerdata layers should know what it is doing.
Thanks,
Amir.
Re: [PATCH 2/5] ovl: introduce data-only lower layers
Quoted 18 lines · Amir Goldstein
Quoted 6 lines · Alexander Larsson
Quoted 6 lines
*
fh->uuidto layer.(quoted diff) +0
-0@@ -907,7 +907,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,Quoted 9 lines
Quoted 7 lines
fs/overlayfs/namei.c +1
-1if (!d.stop && ovl_numlower(poe)) { err = -ENOMEM; - stack = ovl_stack_alloc(ofs->numlayer - 1); + stack = ovl_stack_alloc(ovl_numlowerlayer(ofs)); if (!stack) goto out_put_upper;}
Again, surely
ovl_numlower(poe)is a better size here?
Quoted 4 lines
Intentional. that is changed in the following patch. (to
ovl_numlowerlayer(ofs)+ 1)
As the commit message says:
"Following changes will implement lookup in the data layers."
Still, you might have 10 lower layers in the overlay mount overall, but this particular parent may only have 1 lower layer, no? So numlower(poe) would be smaller that numlowerlayer(ofs).
Signature · 10 lines
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=-=
Alexander Larsson Red Hat,
Inc
[email protected] [email protected]
He's an all-American vegetarian romance novelist who must take
medication
to keep him sane. She's a vivacious extravagent stripper from Mars.
They
fight crime! Amir Goldstein
maintainerRe: [PATCH 2/5] ovl: introduce data-only lower layers
Quoted 20 lines · Alexander Larsson
Quoted 18 lines · Amir Goldstein
Quoted 15 lines · Alexander Larsson
Quoted 12 lines
*
fh->uuidto layer.fs/overlayfs/namei.c +1
-1@@ -907,7 +907,7 @@ struct dentry *ovl_lookup(struct inode *dir,struct dentry *dentry, if (!d.stop && ovl_numlower(poe)) { err = -ENOMEM ; - stack =ovl_stack_alloc (ofs->numlayer -1 ); + stack =ovl_stack_alloc (ovl_numlowerlayer (ofs));if (!stack) goto out_put_upper;Quoted 1 line
}Again, surely
ovl_numlower(poe)is a better size here?
Quoted 8 lines
Quoted 4 lines
Intentional. that is changed in the following patch. (to
ovl_numlowerlayer(ofs)+ 1)
As the commit message says:
"Following changes will implement lookup in the data layers."Still, you might have 10 lower layers in the overlay mount overall, but this particular parent may only have 1 lower layer, no? So numlower(poe) would be smaller that numlowerlayer(ofs).
Ah, I understand your question.
The answer is that absolute redirect (a.k.a poe = roe) can change numlower(poe) after the stack was allocated.
There are several "optimizations" that could be done, but they are useless, because stack is a temporary allocation. The permanent stack allocation is done at the end of lookup with ovl_alloc_entry(ctr).
Which means I could have also left it ofs->numlayer - 1 this change ends up being just semantic.
Thanks,
Amir.
Amir Goldstein
maintainerPATCH 3/5 ovl: implement lookup in data-only layers
In reply to Amir GoldsteinLookup in data-only layers only for a lower metacopy with an absolute redirect xattr.
The metacopy xattr is not checked on files found in the data-only layers and redirect xattr are not followed in the data-only layers.
--- fs/overlayfs/namei.c | 77 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 75 insertions(+), 2 deletions(-)
fs/overlayfs/namei.c +75 -2
@@ -14,6 +14,8 @@#include <linux/exportfs.h> #include "overlayfs.h" +#include "../internal.h" /* for vfs_path_lookup */ +struct ovl_lookup_data {struct super_block *sb;struct vfsmount *mnt;
@@ -24,6 +26,8 @@ struct ovl_lookup_data {bool last;char *redirect;bool metacopy; +/* Referring to last redirect xattr */ +bool absolute_redirect; }; static int ovl_check_redirect(const struct path *path, struct ovl_lookup_data *d,
@@ -33,11 +37,13 @@ static int ovl_check_redirect(const struct path *path, struct ovl_lookup_data *dchar *buf;struct ovl_fs *ofs =OVL_FS (d->sb); + d->absolute_redirect = false; buf =ovl_get_redirect_xattr (ofs, path, prelen +strlen (post));if (IS_ERR_OR_NULL (buf))return PTR_ERR (buf);if (buf[0 ] =='/' ) { + d->absolute_redirect = true;/* * One of the ancestor path elements in an absolute path * lookup in ovl_lookup_layer() could have been opaque and
@@ -349,6 +355,61 @@ static int ovl_lookup_layer(struct dentry *base, struct ovl_lookup_data *d,return 0 ; } +static int ovl_lookup_data_layer (struct dentry *dentry,const char *redirect, +const struct ovl_layer *layer, +struct path *datapath) +{ +int err; + + err =vfs_path_lookup (layer->mnt->mnt_root, layer->mnt, redirect, +LOOKUP_BENEATH |LOOKUP_NO_SYMLINKS |LOOKUP_NO_XDEV , + datapath); +pr_debug ("lookup lowerdata (%pd2, redirect=\"%s\", layer=%d, err=%i)\n" , + dentry, redirect, layer->idx, err); + +if (err) +return err; + + err = -EREMOTE ; +if (ovl_dentry_weird (datapath->dentry)) + goto out_path_put; + + err = -ENOENT ; +/* Only regular file is acceptable as lower data */ +if (!d_is_reg (datapath->dentry)) + goto out_path_put; + +return 0 ; + +out_path_put: +path_put (datapath); + +return err; +} + +/* Lookup in data-only layers by absolute redirect to layer root */ +static int ovl_lookup_data_layers (struct dentry *dentry,const char *redirect, +struct ovl_path *lowerdata) +{ +struct ovl_fs *ofs =OVL_FS (dentry->d_sb); +const struct ovl_layer *layer; +struct path datapath; +int err = -ENOENT ; +int i; + + layer = &ofs->layers[ofs->numlayer - ofs->numdatalayer]; +for (i =0 ; i < ofs->numdatalayer; i++, layer++) { + err =ovl_lookup_data_layer (dentry, redirect, layer, &datapath); +if (!err) { +mntput (datapath.mnt); + lowerdata->dentry = datapath.dentry; + lowerdata->layer = layer; +return 0 ; + } + } + +return err; +}int ovl_check_origin_fh (struct ovl_fs *ofs,struct ovl_fh *fh,bool connected,struct dentry *upperdentry,struct ovl_path **stackp)
@@ -907,7 +968,9 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,if (!d.stop &&ovl_numlower (poe)) { err = -ENOMEM ; - stack =ovl_stack_alloc (ovl_numlowerlayer (ofs)); +/* May need to reserve space in lowerstack for lowerdata */ + stack =ovl_stack_alloc (ovl_numlowerlayer (ofs) + + (!d.is_dir && !!ofs->numdatalayer));if (!stack) goto out_put_upper; }
@@ -917,7 +980,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,if (!ofs->config.redirect_follow) d.last = i ==ovl_numlower (poe) -1 ; -else +else if (d.is_dir || !ofs->numdatalayer) d.last = lower.layer->idx ==ovl_numlower (roe); d.mnt = lower.layer->mnt;
@@ -1011,6 +1074,16 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, } } +/* Lookup absolute redirect from lower metacopy in data-only layers */ +if (d.metacopy && ctr && ofs->numdatalayer && d.absolute_redirect) { + err =ovl_lookup_data_layers (dentry, d.redirect, + &stack[ctr]); +if (!err) { + d.metacopy = false; + ctr++; + } + } +/* * For regular non-metacopy upper dentries, there is no lower * path based lookup, hence ctr will be zero. If a dentry is found
Signature · 1 line
2.34.1
Re: [PATCH 3/5] ovl: implement lookup in data-only layers
Quoted 8 lines · Amir Goldstein
Lookup in data-only layers only for a lower metacopy with an absolute redirect xattr.
The metacopy xattr is not checked on files found in the data-only layers
and redirect xattr are not followed in the data-only layers.Signed-off-by Amir Goldstein <[email protected]>
Quoted 119 lines
---
fs/overlayfs/namei.c | 77
++++++++++++++++++++++++++++++++++++++++++--1 file changed, 75 insertions(+), 2 deletions(-)fs/overlayfs/namei.c +0
-0@@ -14,6 +14,8 @@ #include <linux/exportfs.h> #include "overlayfs.h"fs/overlayfs/namei.c +2
-0+#include "../internal.h" /* for vfs_path_lookup */ +struct
ovl_lookup_data{
structsuper_block*sb;
struct vfsmount *mnt;fs/overlayfs/namei.c +2
-0@@ -24,6 +26,8 @@ struct ovl_lookup_data { bool last; char *redirect; bool metacopy; + /* Referring to last redirect xattr */ + bool absolute_redirect; };
static int ovl_check_redirect(const struct path *path, structovl_lookup_data*d,fs/overlayfs/namei.c +0
-0@@ -33,11 +37,13 @@ static int ovl_check_redirect(const struct path *path, struct ovl_lookup_data *d char *buf; struct ovl_fs *ofs = OVL_FS(d->sb);
+ d->absolute_redirect = false;
buf =ovl_get_redirect_xattr(ofs, path, prelen + strlen(post));
if (IS_ERR_OR_NULL(buf))
returnPTR_ERR(buf);
if (buf[0] == '/') {
+ d->absolute_redirect = true;
/*
* One of the ancestor path elements in an absolute path
* lookup inovl_lookup_layer()could have been opaque andfs/overlayfs/namei.c +0
-0@@ -349,6 +355,61 @@ static int ovl_lookup_layer(struct dentry *base, struct ovl_lookup_data *d, return 0; }
+static int ovl_lookup_data_layer(struct dentry *dentry, const char *redirect,
+ const structovl_layer*layer, + struct path *datapath)fs/overlayfs/namei.c +4
-0+{ + int err; + + err = vfs_path_lookup(layer->mnt->mnt_root, layer->mnt,redirect,
+ LOOKUP_BENEATH |LOOKUP_NO_SYMLINKS|LOOKUP_NO_XDEV,
+ datapath);
+ pr_debug("lookup lowerdata (%pd2, redirect=\"%s\", layer=%d, err=%i)\n",
+ dentry, redirect,layer->idx, err);fs/overlayfs/namei.c +23
-0+ + if (err) + return err; + + err = -EREMOTE; + if (ovl_dentry_weird(datapath->dentry)) + goto out_path_put; + + err = -ENOENT; + /* Only regular file is acceptable as lower data */ + if (!d_is_reg(datapath->dentry)) + goto out_path_put; + + return 0; + +out_path_put: + path_put(datapath); + + return err; +} + +/* Lookup in data-only layers by absolute redirect to layer root */ +static int ovl_lookup_data_layers(struct dentry *dentry, const char*redirect,
+ structovl_path*lowerdata)fs/overlayfs/namei.c +10
-0+{ + struct ovl_fs *ofs = OVL_FS(dentry->d_sb); + const struct ovl_layer *layer; + struct path datapath; + int err = -ENOENT; + int i; + + layer = &ofs->layers[ofs->numlayer - ofs->numdatalayer]; + for (i = 0; i < ofs->numdatalayer; i++, layer++) { + err = ovl_lookup_data_layer(dentry, redirect, layer,&datapath);
+ if (!err) {
+ mntput(datapath.mnt);
+ lowerdata->dentry = datapath.dentry; + lowerdata->layer = layer; + return 0;
+ }
+ }fs/overlayfs/namei.c +3
-0+ + return err; +}
int ovl_check_origin_fh(structovl_fs*ofs, structovl_fh*fh, bool connected,
struct dentry *upperdentry, structovl_path**stackp)fs/overlayfs/namei.c +0
-0@@ -907,7 +968,9 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
Quoted 9 lines
if (!d.stop &&ovl_numlower(poe)) {
err =-ENOMEM;
- stack = ovl_stack_alloc(ovl_numlowerlayer(ofs)); + /* May need to reserve space in lowerstack for lowerdata */
+ stack = ovl_stack_alloc(ovl_numlowerlayer(ofs) + + (!d.is_dir && !!ofs-Quoted 1 line
numdatalayer));
I think this runs into issues if ovl_numlower(poe) is zero, but we have a redirect into the lowerdata, due to the if (ovl_numlower(poe)) check above. We won't be allocating the lowerdata stack space in this case.
Quoted 22 lines
if (!stack)
gotoout_put_upper;
}fs/overlayfs/namei.c +0
-0@@ -917,7 +980,7 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
if (!ofs->config.redirect_follow) d.last = i ==ovl_numlower(poe)- 1; - else
+ else if (d.is_dir || !ofs->numdatalayer) d.last =lower.layer->idx==ovl_numlower(roe);
d.mnt =lower.layer->mnt;fs/overlayfs/namei.c +0
-0@@ -1011,6 +1074,16 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, } }
+ /* Lookup absolute redirect from lower metacopy in data-only layers */
+ if (d.metacopy && ctr &&ofs->numdatalayer&&
Quoted 8 lines
d.absolute_redirect) {
+ err = ovl_lookup_data_layers(dentry, d.redirect, + &stack[ctr]); + if (!err) {
+ d.metacopy = false;
+ ctr++;
+ }
+ }
This code runs even if ofs->config.redirect_follow is false. I think this is probably correct, but maybe it should be mentioned in the docs?
Quoted 5 lines
+
/*
* For regular non-metacopy upper dentries, there is no lower
* path based lookup, hence ctr will be zero. If a dentry is found
Signature · 8 lines
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=-=
Alexander Larsson Red Hat,
Inc
[email protected] [email protected]
He's a war-weary chivalrous boxer living undercover at Ringling Bros.
Circus. She's a violent nymphomaniac mercenary fleeing from a Satanic
cult. They fight crime! Amir Goldstein
maintainerRe: [PATCH 3/5] ovl: implement lookup in data-only layers
Quoted 140 lines · Alexander Larsson
Quoted 8 lines · Amir Goldstein
Lookup in data-only layers only for a lower metacopy with an absolute redirect xattr.
The metacopy xattr is not checked on files found in the data-only layers
and redirect xattr are not followed in the data-only layers.Signed-off-by Amir Goldstein <[email protected]>Reviewed-by Alexander Larsson <[email protected]>Quoted 127 lines
--- fs/overlayfs/namei.c | 77 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 75 insertions(+), 2 deletions(-)fs/overlayfs/namei.c +4
-0@@ -14,6 +14,8 @@#include <linux/exportfs.h> #include "overlayfs.h" +#include "../internal.h" /* for vfs_path_lookup */ +struct ovl_lookup_data {struct super_block *sb;struct vfsmount *mnt;@@ -24,6 +26,8 @@ struct ovl_lookup_data {bool last;char *redirect;bool metacopy; +/* Referring to last redirect xattr */ +bool absolute_redirect; }; static int ovl_check_redirect(const struct path *path, struct
ovl_lookup_data*d,fs/overlayfs/namei.c +2
-0@@ -33,11 +37,13 @@ static int ovl_check_redirect(const struct path *path, struct ovl_lookup_data *d char *buf;struct ovl_fs *ofs =OVL_FS (d->sb); + d->absolute_redirect = false; buf =ovl_get_redirect_xattr (ofs, path, prelen +strlen (post));if (IS_ERR_OR_NULL (buf))return PTR_ERR (buf);if (buf[0 ] =='/' ) { + d->absolute_redirect = true;/* * One of the ancestor path elements in an absolute
path
* lookup inovl_lookup_layer()could have been
opaque andfs/overlayfs/namei.c +8
-0@@ -349,6 +355,61 @@ static int ovl_lookup_layer(struct dentry *base,struct ovl_lookup_data *d, return 0; } +static int ovl_lookup_data_layer (struct dentry *dentry,const char *redirect, +const struct ovl_layer *layer, +struct path *datapath) +{ +int err; + + err = vfs_path_lookup(layer->mnt->mnt_root, layer->mnt, redirect, + LOOKUP_BENEATH | LOOKUP_NO_SYMLINKS |
LOOKUP_NO_XDEV,fs/overlayfs/namei.c +2
-0+ datapath); + pr_debug("lookup lowerdata (%pd2, redirect=\"%s\", layer=%d,err=%i)\n",
fs/overlayfs/namei.c +24
-0+ dentry, redirect, layer->idx, err); + +if (err) +return err; + + err = -EREMOTE ; +if (ovl_dentry_weird (datapath->dentry)) + goto out_path_put; + + err = -ENOENT ; +/* Only regular file is acceptable as lower data */ +if (!d_is_reg (datapath->dentry)) + goto out_path_put; + +return 0 ; + +out_path_put: +path_put (datapath); + +return err; +} + +/* Lookup in data-only layers by absolute redirect to layer root */ +static int ovl_lookup_data_layers(struct dentry *dentry, const char*redirect,
fs/overlayfs/namei.c +11
-0+ struct ovl_path *lowerdata) +{ +struct ovl_fs *ofs =OVL_FS (dentry->d_sb); +const struct ovl_layer *layer; +struct path datapath; +int err = -ENOENT ; +int i; + + layer = &ofs->layers[ofs->numlayer - ofs->numdatalayer]; +for (i =0 ; i < ofs->numdatalayer; i++, layer++) { + err = ovl_lookup_data_layer(dentry, redirect, layer,&datapath);
fs/overlayfs/namei.c +10
-0+if (!err) { +mntput (datapath.mnt); + lowerdata->dentry = datapath.dentry; + lowerdata->layer = layer; +return 0 ; + } + } + +return err; +} int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, boolconnected,
struct dentry *upperdentry, structovl_path
**stackp)fs/overlayfs/namei.c +1
-1@@ -907,7 +968,9 @@ struct dentry *ovl_lookup(struct inode *dir,struct dentry *dentry, if (!d.stop && ovl_numlower(poe)) { err = -ENOMEM ; - stack =ovl_stack_alloc (ovl_numlowerlayer (ofs)); +/* May need to reserve space in lowerstack for lowerdata */
fs/overlayfs/namei.c +2
-0+ stack = ovl_stack_alloc(ovl_numlowerlayer(ofs) + + (!d.is_dir && !!ofs-
Quoted 7 lines
Quoted 1 line
Quoted 1 line
numdatalayer));
I think this runs into issues if
ovl_numlower(poe)is zero, but we have a redirect into the lowerdata, due to the if (ovl_numlower(poe)) check above. We won't be allocating the lowerdata stack space in this case.
Redirect from upper directly into data-only is not valid. As the comment below says:
/* Lookup absolute redirect from lower metacopy in data-only layers */ data-only can only be accessed by absolute redirect from lower layer.
Is that a problem for your use case?
Quoted 19 lines
Quoted 19 lines
if (!stack) goto out_put_upper; }fs/overlayfs/namei.c +1
-1@@ -917,7 +980,7 @@ struct dentry *ovl_lookup(struct inode *dir,struct dentry *dentry, if (!ofs->config.redirect_follow) d.last = i == ovl_numlower(poe) - 1; - else + else if (d.is_dir || !ofs->numdatalayer) d.last = lower.layer->idx ==ovl_numlower (roe);d.mnt = lower.layer->mnt;fs/overlayfs/namei.c +0
-0@@ -1011,6 +1074,16 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, } }
Quoted 15 lines
fs/overlayfs/namei.c struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, · line 1085
Quoted 11 lines
fs/overlayfs/namei.c +1
-0+/* Lookup absolute redirect from lower metacopy in data-only layers */
+ if (d.metacopy && ctr &&ofs->numdatalayer&&
d.absolute_redirect) {fs/overlayfs/namei.c +7
-0+ err =ovl_lookup_data_layers (dentry, d.redirect, + &stack[ctr]); +if (!err) { + d.metacopy = false; + ctr++; + } + }This code runs even if
ofs->config.redirect_followis false. I think this is probably correct, but maybe it should be mentioned in the docs?
ofs->numdatalayer > 0 depends on ofs->config.metacopy which depends on ofs->config.redirect or ofs->config.redirect_follow.
Thanks,
Amir.
Re: [PATCH 3/5] ovl: implement lookup in data-only layers
Quoted 144 lines · Amir Goldstein
Quoted 142 lines · Alexander Larsson
Quoted 8 lines · Amir Goldstein
Lookup in data-only layers only for a lower metacopy with an absolute redirect xattr.
The metacopy xattr is not checked on files found in the data-only layers
and redirect xattr are not followed in the data-only layers.Signed-off-by Amir Goldstein <[email protected]>Reviewed-by Alexander Larsson <[email protected]>Quoted 128 lines
--- fs/overlayfs/namei.c | 77 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 75 insertions(+), 2 deletions(-)fs/overlayfs/namei.c +4
-0@@ -14,6 +14,8 @@#include <linux/exportfs.h> #include "overlayfs.h" +#include "../internal.h" /* for vfs_path_lookup */ +struct ovl_lookup_data {struct super_block *sb;struct vfsmount *mnt;@@ -24,6 +26,8 @@ struct ovl_lookup_data {bool last;char *redirect;bool metacopy; +/* Referring to last redirect xattr */ +bool absolute_redirect; }; static int ovl_check_redirect(const struct path *path, struct
ovl_lookup_data*d,fs/overlayfs/namei.c +2
-0@@ -33,11 +37,13 @@ static int ovl_check_redirect(const struct path *path, struct ovl_lookup_data *d char *buf;struct ovl_fs *ofs =OVL_FS (d->sb); + d->absolute_redirect = false; buf =ovl_get_redirect_xattr (ofs, path, prelen +strlen (post));if (IS_ERR_OR_NULL (buf))return PTR_ERR (buf);if (buf[0 ] =='/' ) { + d->absolute_redirect = true;/* * One of the ancestor path elements in an absolute
path
* lookup inovl_lookup_layer()could have been
opaque andfs/overlayfs/namei.c +8
-0@@ -349,6 +355,61 @@ static int ovl_lookup_layer(struct dentry *base,struct ovl_lookup_data *d, return 0; } +static int ovl_lookup_data_layer (struct dentry *dentry,const char *redirect, +const struct ovl_layer *layer, +struct path *datapath) +{ +int err; + + err = vfs_path_lookup(layer->mnt->mnt_root, layer->mnt, redirect, + LOOKUP_BENEATH | LOOKUP_NO_SYMLINKS |
LOOKUP_NO_XDEV,fs/overlayfs/namei.c +2
-0+ datapath); + pr_debug("lookup lowerdata (%pd2, redirect=\"%s\", layer=%d,err=%i)\n",
fs/overlayfs/namei.c +24
-0+ dentry, redirect, layer->idx, err); + +if (err) +return err; + + err = -EREMOTE ; +if (ovl_dentry_weird (datapath->dentry)) + goto out_path_put; + + err = -ENOENT ; +/* Only regular file is acceptable as lower data */ +if (!d_is_reg (datapath->dentry)) + goto out_path_put; + +return 0 ; + +out_path_put: +path_put (datapath); + +return err; +} + +/* Lookup in data-only layers by absolute redirect to layer root */ +static int ovl_lookup_data_layers(struct dentry *dentry, const char*redirect,
fs/overlayfs/namei.c +11
-0+ struct ovl_path *lowerdata) +{ +struct ovl_fs *ofs =OVL_FS (dentry->d_sb); +const struct ovl_layer *layer; +struct path datapath; +int err = -ENOENT ; +int i; + + layer = &ofs->layers[ofs->numlayer - ofs->numdatalayer]; +for (i =0 ; i < ofs->numdatalayer; i++, layer++) { + err = ovl_lookup_data_layer(dentry, redirect, layer,&datapath);
fs/overlayfs/namei.c +10
-0+if (!err) { +mntput (datapath.mnt); + lowerdata->dentry = datapath.dentry; + lowerdata->layer = layer; +return 0 ; + } + } + +return err; +} int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, boolconnected,
struct dentry *upperdentry, structovl_path
**stackp)fs/overlayfs/namei.c +1
-1@@ -907,7 +968,9 @@ struct dentry *ovl_lookup(struct inode *dir,struct dentry *dentry, if (!d.stop && ovl_numlower(poe)) { err = -ENOMEM ; - stack =ovl_stack_alloc (ovl_numlowerlayer (ofs)); +/* May need to reserve space in lowerstack for lowerdata */
fs/overlayfs/namei.c +2
-0+ stack = ovl_stack_alloc(ovl_numlowerlayer(ofs) + + (!d.is_dir && !!ofs-Quoted 1 line
numdatalayer));
Quoted 7 lines
Quoted 5 lines
I think this runs into issues if
ovl_numlower(poe)is zero, but we have a redirect into the lowerdata, due to the if (ovl_numlower(poe)) check above. We won't be allocating the lowerdata stack space in this case.Redirect from upper directly into data-only is not valid.
Ah.
Quoted 5 lines
As the comment below says:
/* Lookup absolute redirect from lower metacopy in data-only layers */ data-only can only be accessed by absolute redirect from lower layer.
Is that a problem for your use case?
No, just something I noticed that looked wrong.
Quoted 41 lines
Quoted 19 lines
Quoted 19 lines
if (!stack) goto out_put_upper; }fs/overlayfs/namei.c +1
-1@@ -917,7 +980,7 @@ struct dentry *ovl_lookup(struct inode *dir,struct dentry *dentry, if (!ofs->config.redirect_follow) d.last = i == ovl_numlower(poe) - 1; - else + else if (d.is_dir || !ofs->numdatalayer) d.last = lower.layer->idx ==ovl_numlower (roe);d.mnt = lower.layer->mnt;fs/overlayfs/namei.c +0
-0@@ -1011,6 +1074,16 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, } }Quoted 15 lines
fs/overlayfs/namei.c struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, · line 1085
Quoted 11 lines
fs/overlayfs/namei.c +1
-0+/* Lookup absolute redirect from lower metacopy in data-only layers */
+ if (d.metacopy && ctr &&ofs->numdatalayer&&
d.absolute_redirect) {fs/overlayfs/namei.c +7
-0+ err =ovl_lookup_data_layers (dentry, d.redirect, + &stack[ctr]); +if (!err) { + d.metacopy = false; + ctr++; + } + }This code runs even if
ofs->config.redirect_followis false. I think this is probably correct, but maybe it should be mentioned in the docs?
ofs->numdatalayer> 0 depends onofs->config.metacopywhich depends onofs->config.redirectorofs->config.redirect_follow.Thanks,
Amir.
Signature · 3 lines
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Alexander Larsson Red Hat, Inc
[email protected] [email protected]Amir Goldstein
maintainerRe: [PATCH 3/5] ovl: implement lookup in data-only layers
Quoted 156 lines · Alexander Larsson
Quoted 144 lines · Amir Goldstein
Quoted 142 lines · Alexander Larsson
Quoted 8 lines · Amir Goldstein
Lookup in data-only layers only for a lower metacopy with an absolute redirect xattr.
The metacopy xattr is not checked on files found in the data-only layers
and redirect xattr are not followed in the data-only layers.Signed-off-by Amir Goldstein <[email protected]>Reviewed-by Alexander Larsson <[email protected]>Quoted 128 lines
--- fs/overlayfs/namei.c | 77 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 75 insertions(+), 2 deletions(-)fs/overlayfs/namei.c +4
-0@@ -14,6 +14,8 @@#include <linux/exportfs.h> #include "overlayfs.h" +#include "../internal.h" /* for vfs_path_lookup */ +struct ovl_lookup_data {struct super_block *sb;struct vfsmount *mnt;@@ -24,6 +26,8 @@ struct ovl_lookup_data {bool last;char *redirect;bool metacopy; +/* Referring to last redirect xattr */ +bool absolute_redirect; }; static int ovl_check_redirect(const struct path *path, struct
ovl_lookup_data*d,fs/overlayfs/namei.c +2
-0@@ -33,11 +37,13 @@ static int ovl_check_redirect(const struct path *path, struct ovl_lookup_data *d char *buf;struct ovl_fs *ofs =OVL_FS (d->sb); + d->absolute_redirect = false; buf =ovl_get_redirect_xattr (ofs, path, prelen +strlen (post));if (IS_ERR_OR_NULL (buf))return PTR_ERR (buf);if (buf[0 ] =='/' ) { + d->absolute_redirect = true;/* * One of the ancestor path elements in an absolute
path
* lookup inovl_lookup_layer()could have been
opaque andfs/overlayfs/namei.c +8
-0@@ -349,6 +355,61 @@ static int ovl_lookup_layer(struct dentry *base,struct ovl_lookup_data *d, return 0; } +static int ovl_lookup_data_layer (struct dentry *dentry,const char *redirect, +const struct ovl_layer *layer, +struct path *datapath) +{ +int err; + + err = vfs_path_lookup(layer->mnt->mnt_root, layer->mnt, redirect, + LOOKUP_BENEATH | LOOKUP_NO_SYMLINKS |
LOOKUP_NO_XDEV,fs/overlayfs/namei.c +2
-0+ datapath); + pr_debug("lookup lowerdata (%pd2, redirect=\"%s\", layer=%d,err=%i)\n",
fs/overlayfs/namei.c +24
-0+ dentry, redirect, layer->idx, err); + +if (err) +return err; + + err = -EREMOTE ; +if (ovl_dentry_weird (datapath->dentry)) + goto out_path_put; + + err = -ENOENT ; +/* Only regular file is acceptable as lower data */ +if (!d_is_reg (datapath->dentry)) + goto out_path_put; + +return 0 ; + +out_path_put: +path_put (datapath); + +return err; +} + +/* Lookup in data-only layers by absolute redirect to layer root */ +static int ovl_lookup_data_layers(struct dentry *dentry, const char*redirect,
fs/overlayfs/namei.c +11
-0+ struct ovl_path *lowerdata) +{ +struct ovl_fs *ofs =OVL_FS (dentry->d_sb); +const struct ovl_layer *layer; +struct path datapath; +int err = -ENOENT ; +int i; + + layer = &ofs->layers[ofs->numlayer - ofs->numdatalayer]; +for (i =0 ; i < ofs->numdatalayer; i++, layer++) { + err = ovl_lookup_data_layer(dentry, redirect, layer,&datapath);
fs/overlayfs/namei.c +10
-0+if (!err) { +mntput (datapath.mnt); + lowerdata->dentry = datapath.dentry; + lowerdata->layer = layer; +return 0 ; + } + } + +return err; +} int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, boolconnected,
struct dentry *upperdentry, structovl_path
**stackp)fs/overlayfs/namei.c +1
-1@@ -907,7 +968,9 @@ struct dentry *ovl_lookup(struct inode *dir,struct dentry *dentry, if (!d.stop && ovl_numlower(poe)) { err = -ENOMEM ; - stack =ovl_stack_alloc (ovl_numlowerlayer (ofs)); +/* May need to reserve space in lowerstack for lowerdata */
fs/overlayfs/namei.c +2
-0+ stack = ovl_stack_alloc(ovl_numlowerlayer(ofs) + + (!d.is_dir && !!ofs-Quoted 1 line
numdatalayer));
Quoted 7 lines
Quoted 5 lines
I think this runs into issues if
ovl_numlower(poe)is zero, but we have a redirect into the lowerdata, due to the if (ovl_numlower(poe)) check above. We won't be allocating the lowerdata stack space in this case.Redirect from upper directly into data-only is not valid.
Ah.
Quoted 7 lines
Quoted 5 lines
As the comment below says:
/* Lookup absolute redirect from lower metacopy in data-only layers */ data-only can only be accessed by absolute redirect from lower layer.
Is that a problem for your use case?No, just something I noticed that looked wrong.
I haven't actually explained why that limitation exists.
Apart from the fact that your use case does not need redirect from upper to data-only, when the stack is composed of only upper and lower (not 2 lowers) then the lower is used for the overlay ino/index/fh.
data-only layers cannot be used for ovelray ino/index/fh because they are data-only and ino/fh is metadata.
That's also the reason that data-only layers do not need to go through the ovl_lower_uuid_ok() check, which allows greater flexibility with the filesystems being used for the backing store of the data blobs.
Thanks,
Amir.
Amir Goldstein
maintainerPATCH 4/5 ovl: prepare for lazy lookup of lowerdata inode
In reply to Amir GoldsteinMake the code handle the case of numlower > 1 and missing lowerdata dentry gracefully.
Missing lowerdata dentry is an indication for lazy lookup of lowerdata and in that case the lowerdata_redirect path is stored in ovl_inode.
Following commits will defer lookup and perform the lazy lookup on acccess.
--- fs/overlayfs/export.c | 2 +- fs/overlayfs/file.c | 7 +++++++ fs/overlayfs/inode.c | 18 ++++++++++++++---- fs/overlayfs/super.c | 3 +++ fs/overlayfs/util.c | 2 +- 5 files changed, 26 insertions(+), 6 deletions(-)
fs/overlayfs/export.c +1 -1
@@ -343,7 +343,7 @@ static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)if (!idx)return ovl_dentry_upper (dentry); -for (i =0 ; i <ovl_numlower (oe); i++) { +for (i =0 ; i <ovl_numlower (oe) && lowerstack[i].layer; i++) {if (lowerstack[i].layer->idx == idx)return lowerstack[i].dentry; }
fs/overlayfs/file.c +7 -0
@@ -115,6 +115,9 @@ static int ovl_real_fdget_meta(const struct file *file, struct fd *real,ovl_path_real (dentry, &realpath); else ovl_path_realdata(dentry, &realpath); +/* TODO: lazy lookup of lowerdata */ +if (!realpath.dentry) +return -EIO ;/* Has it been copied up since we'd opened it? */ if (unlikely (file_inode (real->file) !=d_inode (realpath.dentry))) {
@@ -158,6 +161,10 @@ static int ovl_open(struct inode *inode, struct file *file) file->f_flags &= ~(O_CREAT |O_EXCL |O_NOCTTY |O_TRUNC );ovl_path_realdata (dentry, &realpath); +/* TODO: lazy lookup of lowerdata */ +if (!realpath.dentry) +return -EIO ; + realfile =ovl_open_realfile (file, &realpath);if (IS_ERR (realfile))return PTR_ERR (realfile);
fs/overlayfs/inode.c +14 -4
@@ -240,15 +240,22 @@ int ovl_getattr(struct mnt_idmap *idmap, const struct path *path,/* * If lower is not same as lowerdata or if there was * no origin on upper, we can end up here. +* With lazy lowerdata lookup, guess lowerdata blocks +* from size to avoid lowerdata lookup on stat(2). */ struct kstat lowerdatastat;u32 lowermask =STATX_BLOCKS ;ovl_path_lowerdata (dentry, &realpath); - err =vfs_getattr (&realpath, &lowerdatastat, - lowermask, flags); -if (err) - goto out; +if (realpath.dentry) { + err =vfs_getattr (&realpath, &lowerdatastat, + lowermask, flags); +if (err) + goto out; + }else { + lowerdatastat.blocks = +round_up (stat->size, stat->blksize) >>9 ; + } stat->blocks = lowerdatastat.blocks; } }
@@ -710,6 +717,9 @@ static int ovl_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,struct inode *realinode =ovl_inode_realdata (inode);const struct cred *old_cred; +if (!realinode) +return -EIO ; +if (!realinode->i_op->fiemap)return -EOPNOTSUPP ;
fs/overlayfs/super.c +3 -0
@@ -103,6 +103,9 @@ static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) {int ret =1 ; +if (!d) +return 1 ; +if (weak) {if (d->d_flags &DCACHE_OP_WEAK_REVALIDATE ) ret = d->d_op->d_weak_revalidate (d, flags);
fs/overlayfs/util.c +1 -1
@@ -179,7 +179,7 @@ void ovl_dentry_init_flags(struct dentry *dentry, struct dentry *upperdentry,if (upperdentry) flags |= upperdentry->d_flags; -for (i =0 ; i <ovl_numlower (oe); i++) +for (i =0 ; i <ovl_numlower (oe) && lowerstack[i].dentry; i++) flags |= lowerstack[i].dentry->d_flags;spin_lock (&dentry->d_lock);
Signature · 1 line
2.34.1
Re: [PATCH 4/5] ovl: prepare for lazy lookup of lowerdata inode
Quoted 11 lines · Amir Goldstein
Make the code handle the case of numlower > 1 and missing lowerdata dentry gracefully.
Missing lowerdata dentry is an indication for lazy lookup of lowerdata
and in that case thelowerdata_redirectpath is stored inovl_inode.Following commits will defer lookup and perform the lazy lookup on acccess.
Signed-off-by Amir Goldstein <[email protected]>
Quoted 130 lines
---
fs/overlayfs/export.c | 2 +-
fs/overlayfs/file.c | 7 +++++++
fs/overlayfs/inode.c | 18 ++++++++++++++----
fs/overlayfs/super.c | 3 +++
fs/overlayfs/util.c | 2 +-5 files changed, 26 insertions(+), 6 deletions(-)fs/overlayfs/export.c +0
-0@@ -343,7 +343,7 @@ static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx) if (!idx) return ovl_dentry_upper(dentry);
- for (i = 0; i <ovl_numlower(oe); i++) {
+ for (i = 0; i <ovl_numlower(oe)&& lowerstack[i].layer; i++) {
if (lowerstack[i].layer->idx == idx) return lowerstack[i].dentry;
}fs/overlayfs/file.c +0
-0@@ -115,6 +115,9 @@ static int ovl_real_fdget_meta(const struct file *file, struct fd *real, ovl_path_real(dentry, &realpath);else
ovl_path_realdata(dentry, &realpath); + /* TODO: lazy lookup of lowerdata */
+ if (!realpath.dentry)
+ return-EIO;
/* Has it been copied up since we'd opened it? */ if (unlikely(file_inode(real->file) != d_inode(realpath.dentry))) {fs/overlayfs/file.c +0
-0@@ -158,6 +161,10 @@ static int ovl_open(struct inode *inode, struct file *file) file->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
ovl_path_realdata(dentry, &realpath); + /* TODO: lazy lookup of lowerdata */ + if (!realpath.dentry)
+ return-EIO;
+
realfile =ovl_open_realfile(file, &realpath); if (IS_ERR(realfile))
returnPTR_ERR(realfile);fs/overlayfs/inode.c +0
-0@@ -240,15 +240,22 @@ int ovl_getattr(struct mnt_idmap *idmap, const struct path *path, /** If lower is not same as lowerdata or if there was
* no origin on upper, we can end up here. + * With lazy lowerdata lookup, guess lowerdata blocks
+ * from size to avoid lowerdata lookup on stat(2).
*/
struct kstat lowerdatastat;
u32 lowermask =STATX_BLOCKS;
ovl_path_lowerdata(dentry, &realpath); - err = vfs_getattr(&realpath, &lowerdatastat, - lowermask, flags); - if (err)
- goto out;
+ if (realpath.dentry) {
+ err = vfs_getattr(&realpath, &lowerdatastat,
+ lowermask, flags); + if (err)
+ goto out;
+ } else {
+ lowerdatastat.blocks =
+ round_up(stat->size, stat-Quoted 1 line
blksize) >> 9;
+ }
stat->blocks = lowerdatastat.blocks; }
}fs/overlayfs/inode.c +0
-0@@ -710,6 +717,9 @@ static int ovl_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, struct inode *realinode = ovl_inode_realdata(inode); const struct cred *old_cred;
+ if (!realinode)
+ return-EIO;
+if (!realinode->i_op->fiemap)
return-EOPNOTSUPP;fs/overlayfs/super.c +0
-0@@ -103,6 +103,9 @@ static int ovl_revalidate_real(struct dentry *d, unsigned int flags, bool weak) { int ret = 1;
+ if (!d)
+ return 1;
+
if (weak) {
if (d->d_flags&DCACHE_OP_WEAK_REVALIDATE) ret =d->d_op->d_weak_revalidate(d, flags);fs/overlayfs/util.c +0
-0@@ -179,7 +179,7 @@ void ovl_dentry_init_flags(struct dentry *dentry, struct dentry *upperdentry,
if (upperdentry)
flags |=upperdentry->d_flags;
- for (i = 0; i <ovl_numlower(oe); i++)
+ for (i = 0; i <ovl_numlower(oe)&& lowerstack[i].dentry; i++)
flags |= lowerstack[i].dentry->d_flags;
spin_lock(&dentry->d_lock);
Signature · 9 lines
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=-=
Alexander Larsson Red Hat,
Inc
[email protected] [email protected]
He's a time-tossed Amish vagrant who knows the secret of the alien
invasion. She's a high-kicking gypsy barmaid from a family of eight
older
brothers. They fight crime! Miklos Szeredi
maintainerRe: [PATCH 4/5] ovl: prepare for lazy lookup of lowerdata inode
In reply to Amir GoldsteinQuoted 24 lines · Amir Goldstein
Make the code handle the case of numlower > 1 and missing lowerdata dentry gracefully.
Missing lowerdata dentry is an indication for lazy lookup of lowerdata and in that case the
lowerdata_redirectpath is stored inovl_inode.Following commits will defer lookup and perform the lazy lookup on acccess.
Signed-off-by Amir Goldstein <[email protected]>--- fs/overlayfs/export.c | 2 +- fs/overlayfs/file.c | 7 +++++++ fs/overlayfs/inode.c | 18 ++++++++++++++---- fs/overlayfs/super.c | 3 +++ fs/overlayfs/util.c | 2 +- 5 files changed, 26 insertions(+), 6 deletions(-)fs/overlayfs/export.c +0
-0
fs/overlayfs/export.c static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx) · line 346
Quoted 5 lines
fs/overlayfs/export.c +1
-1@@ -343,7 +343,7 @@ static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)if (!idx)return ovl_dentry_upper (dentry); -for (i =0 ; i <ovl_numlower (oe); i++) { +for (i =0 ; i <ovl_numlower (oe) && lowerstack[i].layer; i++) {
Metacopy and NFS export are mutually exclusive, so this doesn't make sense.
fs/overlayfs/super.c
Quoted 4 lines
fs/overlayfs/super.c +0
-0
ovl_d_real() calls ovl_dentry_lowerdata(). If triggered from file_dentry() it should be okay, since that is done on an open file
(lazy lookup already perfromed). But it can also be called fromd_real_inode(), the only caller of which is trace_uprobe. Is this going to be okay?
In any case a comment is needed at least.
Thanks,
Miklos
Amir Goldstein
maintainerRe: [PATCH 4/5] ovl: prepare for lazy lookup of lowerdata inode
Quoted 29 lines · Miklos Szeredi
Quoted 27 lines · Amir Goldstein
Make the code handle the case of numlower > 1 and missing lowerdata dentry gracefully.
Missing lowerdata dentry is an indication for lazy lookup of lowerdata and in that case the
lowerdata_redirectpath is stored inovl_inode.Following commits will defer lookup and perform the lazy lookup on acccess.
Signed-off-by Amir Goldstein <[email protected]>--- fs/overlayfs/export.c | 2 +- fs/overlayfs/file.c | 7 +++++++ fs/overlayfs/inode.c | 18 ++++++++++++++---- fs/overlayfs/super.c | 3 +++ fs/overlayfs/util.c | 2 +- 5 files changed, 26 insertions(+), 6 deletions(-)fs/overlayfs/export.c +0
-0@@ -343,7 +343,7 @@ static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)if (!idx)return ovl_dentry_upper (dentry);
Quoted 5 lines
fs/overlayfs/export.c static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx) · line 346
Quoted 2 lines
fs/overlayfs/export.c +1
-1-for (i =0 ; i <ovl_numlower (oe); i++) { +for (i =0 ; i <ovl_numlower (oe) && lowerstack[i].layer; i++) {Metacopy and NFS export are mutually exclusive, so this doesn't make sense.
OK.
Quoted 12 lines
fs/overlayfs/super.c
Quoted 5 lines
fs/overlayfs/super.c +0
-0
ovl_d_real()callsovl_dentry_lowerdata(). If triggered fromfile_dentry()it should be okay, since that is done on an open file
(lazy lookup already perfromed). But it can also be called fromd_real_inode(), the only caller of which istrace_uprobe. Is this going to be okay?
Not sure.
It's hard to imagine that trace_uprobe_create() is being called to place a probe on a file at offset X without reading the content of symbols first.
I wonder if lazy lookup from within ovl_d_real(d, NULL) is acceptable? It does look like the context of trace_uprobe() callers should be fine for lazy lowerdata lookup.
Quoted 2 lines
In any case a comment is needed at least.
I will leave it as is and add a comment.
Thanks,
Amir.
Amir Goldstein
maintainerRe: [PATCH 4/5] ovl: prepare for lazy lookup of lowerdata inode
Quoted 56 lines · Amir Goldstein
Quoted 29 lines · Miklos Szeredi
Quoted 27 lines · Amir Goldstein
Make the code handle the case of numlower > 1 and missing lowerdata dentry gracefully.
Missing lowerdata dentry is an indication for lazy lookup of lowerdata and in that case the
lowerdata_redirectpath is stored inovl_inode.Following commits will defer lookup and perform the lazy lookup on acccess.
Signed-off-by Amir Goldstein <[email protected]>--- fs/overlayfs/export.c | 2 +- fs/overlayfs/file.c | 7 +++++++ fs/overlayfs/inode.c | 18 ++++++++++++++---- fs/overlayfs/super.c | 3 +++ fs/overlayfs/util.c | 2 +- 5 files changed, 26 insertions(+), 6 deletions(-)fs/overlayfs/export.c +0
-0@@ -343,7 +343,7 @@ static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)if (!idx)return ovl_dentry_upper (dentry);Quoted 5 lines
fs/overlayfs/export.c static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx) · line 346
Quoted 2 lines
fs/overlayfs/export.c +1
-1-for (i =0 ; i <ovl_numlower (oe); i++) { +for (i =0 ; i <ovl_numlower (oe) && lowerstack[i].layer; i++) {Metacopy and NFS export are mutually exclusive, so this doesn't make sense.
OK.
Quoted 12 lines
fs/overlayfs/super.c
Quoted 5 lines
fs/overlayfs/super.c +0
-0
ovl_d_real()callsovl_dentry_lowerdata(). If triggered fromfile_dentry()it should be okay, since that is done on an open file
(lazy lookup already perfromed). But it can also be called fromd_real_inode(), the only caller of which istrace_uprobe. Is this going to be okay?Not sure.
It's hard to imagine thattrace_uprobe_create()is being called to place a probe on a file at offset X without reading the content of symbols first.
Quoted 8 lines
I wonder if lazy lookup from within
ovl_d_real(d, NULL)is acceptable? It does look like the context oftrace_uprobe()callers should be fine for lazy lowerdata lookup.Quoted 2 lines
In any case a comment is needed at least.
I will leave it as is and add a comment.
On second thought, I will add best effort lazy lowerdata lookup in addition to the warning.d_real_inode() does not expect errors or NULL and trace_uprobe does not check for them either.
Thanks,
Amir.
Amir Goldstein
maintainerPATCH 5/5 ovl: implement lazy lookup of lowerdata in data-only layers
In reply to Amir GoldsteinDefer lookup of lowerdata in the data-only layers to first data access or before copy up.
We perform lowerdata lookup before copy up even if copy up is metadata only copy up. We can further optimize this lookup later if needed.
--- fs/overlayfs/copy_up.c | 9 +++++++ fs/overlayfs/file.c | 18 ++++++++++--- fs/overlayfs/namei.c | 56 +++++++++++++++++++++++++++++++++++----- fs/overlayfs/overlayfs.h | 2 ++ fs/overlayfs/ovl_entry.h | 2 +- fs/overlayfs/util.c | 31 +++++++++++++++++++++- 6 files changed, 105 insertions(+), 13 deletions(-)
fs/overlayfs/copy_up.c +9 -0
@@ -1074,6 +1074,15 @@ static int ovl_copy_up_flags(struct dentry *dentry, int flags)if (WARN_ON (disconnected &&d_is_dir (dentry)))return -EIO ; +/* +* We may not need lowerdata if we are only doing metacopy up, but it is +* not very important to optimize this case, so do lazy lowerdata lookup +* before any copy up, so we can do it before taking ovl_inode_lock(). +*/ + err =ovl_maybe_lookup_lowerdata (dentry); +if (err) +return err; + old_cred =ovl_override_creds (dentry->d_sb);while (!err) {struct dentry *next;
fs/overlayfs/file.c +14 -4
@@ -107,15 +107,21 @@ static int ovl_real_fdget_meta(const struct file *file, struct fd *real, {struct dentry *dentry =file_dentry (file);struct path realpath; +int err; real->flags =0 ; real->file = file->private_data; -if (allow_meta) +if (allow_meta) {ovl_path_real (dentry, &realpath); -else + }else { +/* lazy lookup of lowerdata */ + err =ovl_maybe_lookup_lowerdata (dentry); +if (err) +return err; +ovl_path_realdata (dentry, &realpath); -/* TODO: lazy lookup of lowerdata */ + }if (!realpath.dentry)return -EIO ;
@@ -153,6 +159,11 @@ static int ovl_open(struct inode *inode, struct file *file)struct path realpath;int err; +/* lazy lookup of lowerdata */ + err =ovl_maybe_lookup_lowerdata (dentry); +if (err) +return err; + err =ovl_maybe_copy_up (dentry, file->f_flags);if (err)return err;
@@ -161,7 +172,6 @@ static int ovl_open(struct inode *inode, struct file *file) file->f_flags &= ~(O_CREAT |O_EXCL |O_NOCTTY |O_TRUNC );ovl_path_realdata (dentry, &realpath); -/* TODO: lazy lookup of lowerdata */ if (!realpath.dentry)return -EIO ;
fs/overlayfs/namei.c +49 -7
69 lines not on this page · raw message
fs/overlayfs/overlayfs.h +2 -0
@@ -400,6 +400,7 @@ enum ovl_path_type ovl_path_realdata(struct dentry *dentry, struct path *path);struct dentry *ovl_dentry_upper (struct dentry *dentry);struct dentry *ovl_dentry_lower (struct dentry *dentry);struct dentry *ovl_dentry_lowerdata (struct dentry *dentry); +int ovl_dentry_set_lowerdata (struct dentry *dentry,struct ovl_path *datapath);const struct ovl_layer *ovl_i_layer_lower (struct inode *inode);const struct ovl_layer *ovl_layer_lower (struct dentry *dentry);struct dentry *ovl_dentry_real (struct dentry *dentry);
@@ -562,6 +563,7 @@ struct dentry *ovl_get_index_fh(struct ovl_fs *ofs, struct ovl_fh *fh);struct dentry *ovl_lookup_index (struct ovl_fs *ofs,struct dentry *upper,struct dentry *origin,bool verify);int ovl_path_next (int idx,struct dentry *dentry,struct path *path); +int ovl_maybe_lookup_lowerdata (struct dentry *dentry);struct dentry *ovl_lookup (struct inode *dir,struct dentry *dentry,unsigned int flags);bool ovl_lower_positive (struct dentry *dentry);
fs/overlayfs/ovl_entry.h +1 -1
@@ -145,7 +145,7 @@ static inline struct dentry *ovl_lowerdata_dentry(struct ovl_entry *oe) {struct ovl_path *lowerdata =ovl_lowerdata (oe); -return lowerdata ? lowerdata->dentry :NULL ; +return lowerdata ?READ_ONCE (lowerdata->dentry) :NULL ; }/* private information held for every overlayfs dentry */
fs/overlayfs/util.c +30 -1
@@ -250,7 +250,13 @@ void ovl_path_lowerdata(struct dentry *dentry, struct path *path)if (lowerdata_dentry) { path->dentry = lowerdata_dentry; - path->mnt = lowerdata->layer->mnt; +/* +* Pairs with smp_wmb() in ovl_dentry_set_lowerdata(). +* Make sure that if lowerdata->dentry is visible, then +* datapath->layer is visible as well. +*/ +smp_rmb (); + path->mnt =READ_ONCE (lowerdata->layer)->mnt; }else { *path = (struct path ) { }; }
@@ -312,6 +318,29 @@ struct dentry *ovl_dentry_lowerdata(struct dentry *dentry)return ovl_lowerdata_dentry (OVL_E (dentry)); } +int ovl_dentry_set_lowerdata (struct dentry *dentry,struct ovl_path *datapath) +{ +struct ovl_entry *oe =OVL_E (dentry); +struct ovl_path *lowerdata =ovl_lowerdata (oe); +struct dentry *datadentry = datapath->dentry; + +if (WARN_ON_ONCE (ovl_numlower (oe) <=1 )) +return -EIO ; + +WRITE_ONCE (lowerdata->layer, datapath->layer); +/* +* Pairs with smp_rmb() in ovl_path_lowerdata(). +* Make sure that if lowerdata->dentry is visible, then +* lowerdata->layer is visible as well. +*/ +smp_wmb (); +WRITE_ONCE (lowerdata->dentry,dget (datadentry)); + +ovl_dentry_update_reval (dentry, datadentry); + +return 0 ; +} +struct dentry *ovl_dentry_real (struct dentry *dentry) {return ovl_dentry_upper (dentry) ?:ovl_dentry_lower (dentry);
Signature · 1 line
2.34.1
Re: [PATCH 5/5] ovl: implement lazy lookup of lowerdata in data-only layers
Quoted 9 lines · Amir Goldstein
Defer lookup of lowerdata in the data-only layers to first data access
or before copy up.We perform lowerdata lookup before copy up even if copy up is metadata
only copy up. We can further optimize this lookup later if needed.Signed-off-by Amir Goldstein <[email protected]>
LGTM
Quoted 260 lines
---
fs/overlayfs/copy_up.c | 9 +++++++
fs/overlayfs/file.c | 18 ++++++++++--- fs/overlayfs/namei.c | 56 +++++++++++++++++++++++++++++++++++--- --
fs/overlayfs/overlayfs.h | 2 ++
fs/overlayfs/ovl_entry.h | 2 +-
fs/overlayfs/util.c | 31 +++++++++++++++++++++-6 files changed, 105 insertions(+), 13 deletions(-)fs/overlayfs/copy_up.c +0
-0@@ -1074,6 +1074,15 @@ static int ovl_copy_up_flags(struct dentry *dentry, int flags) if (WARN_ON(disconnected && d_is_dir(dentry))) return -EIO;
+ /*
+ * We may not need lowerdata if we are only doing metacopy up, but it is
+ * not very important to optimize this case, so do lazy lowerdata lookup
+ * before any copy up, so we can do it before takingovl_inode_lock().
+ */
+ err =ovl_maybe_lookup_lowerdata(dentry);
+ if (err)
+ return err;
+
old_cred =ovl_override_creds(dentry->d_sb); while (!err) {
struct dentry *next;fs/overlayfs/file.c +1
-0@@ -107,15 +107,21 @@ static int ovl_real_fdget_meta(const struct file *file, struct fd *real, { struct dentry *dentry = file_dentry(file); struct path realpath; + int err;
real->flags = 0;
real->file =file->private_data;
- if (allow_meta)
+ if (allow_meta) {
ovl_path_real(dentry, &realpath); - else
+ } else {
+ /* lazy lookup of lowerdata */
+ err =ovl_maybe_lookup_lowerdata(dentry); + if (err)
+ return err;
+
ovl_path_realdata(dentry, &realpath); - /* TODO: lazy lookup of lowerdata */
+ }
if (!realpath.dentry)
return-EIO;fs/overlayfs/file.c +0
-0@@ -153,6 +159,11 @@ static int ovl_open(struct inode *inode, struct file *file) struct path realpath; int err;
+ /* lazy lookup of lowerdata */
+ err =ovl_maybe_lookup_lowerdata(dentry); + if (err)
+ return err;
+
err =ovl_maybe_copy_up(dentry, file->f_flags); if (err)
return err;fs/overlayfs/file.c +0
-0@@ -161,7 +172,6 @@ static int ovl_open(struct inode *inode, struct file *file) file->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
ovl_path_realdata(dentry, &realpath);
- /* TODO: lazy lookup of lowerdata */
if (!realpath.dentry)
return-EIO;fs/overlayfs/namei.c +0
-0@@ -889,6 +889,52 @@ static int ovl_fix_origin(struct ovl_fs *ofs,struct dentry *dentry, return err; }fs/overlayfs/namei.c +42
-0+/* Lazy lookup of lowerdata */ +int ovl_maybe_lookup_lowerdata (struct dentry *dentry) +{ + struct inode *inode = d_inode(dentry); + const char *redirect = ovl_lowerdata_redirect(inode); + struct ovl_path datapath = {}; + const struct cred *old_cred; + int err; + + if (!redirect || ovl_dentry_lowerdata(dentry)) + return 0; + + if (redirect[0] != '/') + return -EIO; + + err = ovl_inode_lock_interruptible(inode); + if (err) + return err; + + err = 0; + /* Someone got here before us? */ + if (ovl_dentry_lowerdata(dentry)) + goto out; + + old_cred = ovl_override_creds(dentry->d_sb); + err = ovl_lookup_data_layers(dentry, redirect, &datapath); + revert_creds(old_cred); + if (err) + goto out_err; + + err = ovl_dentry_set_lowerdata(dentry, &datapath); + if (err) + goto out_err; + +out: + ovl_inode_unlock(inode); + dput(datapath.dentry); + + return err; + +out_err: + pr_warn_ratelimited("lazy lowerdata lookup failed (%pd2,err=%i)\n",
+ dentry, err);
+ goto out;fs/overlayfs/namei.c +2
-0+} +struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
{fs/overlayfs/namei.c +0
-0@@ -1074,14 +1120,10 @@ struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, } }
- /* Lookup absolute redirect from lower metacopy in data-only layers */
+ /* Defer lookup of lowerdata in data-only layers to first access */
if (d.metacopy && ctr &&ofs->numdatalayer&& d.absolute_redirect) {
- err = ovl_lookup_data_layers(dentry, d.redirect, - &stack[ctr]); - if (!err) {
- d.metacopy = false;
- ctr++;
- }
+ d.metacopy = false;
+ ctr++;
}
/*fs/overlayfs/overlayfs.h +1
-0@@ -400,6 +400,7 @@ enum ovl_path_type ovl_path_realdata(struct dentry *dentry, struct path *path); struct dentry *ovl_dentry_upper(struct dentry *dentry); struct dentry *ovl_dentry_lower(struct dentry *dentry); struct dentry *ovl_dentry_lowerdata(struct dentry *dentry); +int ovl_dentry_set_lowerdata (struct dentry *dentry,struct ovl_path *datapath); const struct ovl_layer *ovl_i_layer_lower(struct inode *inode);const struct
ovl_layer*ovl_layer_lower(struct dentry *dentry); struct dentry *ovl_dentry_real(struct dentry *dentry);fs/overlayfs/overlayfs.h +0
-0@@ -562,6 +563,7 @@ struct dentry *ovl_get_index_fh(struct ovl_fs *ofs, struct ovl_fh *fh);struct dentry *ovl_lookup_index(struct
ovl_fs*ofs, struct dentry *upper,
struct dentry *origin, bool verify); intovl_path_next(int idx, struct dentry *dentry, struct path *path);
+intovl_maybe_lookup_lowerdata(struct dentry *dentry); struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags);
boolovl_lower_positive(struct dentry *dentry);fs/overlayfs/ovl_entry.h +0
-0@@ -145,7 +145,7 @@ static inline struct dentry *ovl_lowerdata_dentry(struct ovl_entry *oe) { struct ovl_path *lowerdata = ovl_lowerdata(oe);
- return lowerdata ?lowerdata->dentry: NULL; + return lowerdata ?READ_ONCE(lowerdata->dentry): NULL; }
/* private information held for every overlayfs dentry */fs/overlayfs/util.c +0
-0@@ -250,7 +250,13 @@ void ovl_path_lowerdata(struct dentry *dentry, struct path *path)
if (lowerdata_dentry) {
path->dentry =lowerdata_dentry;
- path->mnt =lowerdata->layer->mnt;
+ /*
+ * Pairs withsmp_wmb()inovl_dentry_set_lowerdata().
+ * Make sure that iflowerdata->dentryis visible, then
+ *datapath->layeris visible as well. + */
+ smp_rmb();
+ path->mnt = READ_ONCE(lowerdata->layer)->mnt; } else {
*path = (struct path) { };
}fs/overlayfs/util.c +0
-0@@ -312,6 +318,29 @@ struct dentry *ovl_dentry_lowerdata(struct dentry *dentry) return ovl_lowerdata_dentry(OVL_E(dentry)); }
+intovl_dentry_set_lowerdata(struct dentry *dentry, struct ovl_path *datapath)fs/overlayfs/util.c +22
-0+{ + struct ovl_entry *oe = OVL_E(dentry); + struct ovl_path *lowerdata = ovl_lowerdata(oe); + struct dentry *datadentry = datapath->dentry; + + if (WARN_ON_ONCE(ovl_numlower(oe) <= 1)) + return -EIO; + + WRITE_ONCE(lowerdata->layer, datapath->layer); + /* + * Pairs with smp_rmb() in ovl_path_lowerdata(). + * Make sure that if lowerdata->dentry is visible, then + * lowerdata->layer is visible as well. + */ + smp_wmb(); + WRITE_ONCE(lowerdata->dentry, dget(datadentry)); + + ovl_dentry_update_reval(dentry, datadentry); + + return 0; +} +struct dentry *ovl_dentry_real(struct dentry *dentry)
{
returnovl_dentry_upper(dentry)?:ovl_dentry_lower(dentry);
Signature · 8 lines
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
=-=-=
Alexander Larsson Red Hat,
Inc
[email protected] [email protected]
He's an unconventional arachnophobic ex-con fleeing from a secret
government programme. She's a strong-willed motormouth politician from
out of town. They fight crime!