From 6246e761f9e5b55dc555c7c9c505fc30226e819b Mon Sep 17 00:00:00 2001 From: Rmys Date: Thu, 10 Sep 2020 11:33:43 +0300 Subject: [PATCH] kernel-5.8.8 --- kernel/drivers/module-bbswitch/pspec.xml | 11 +- kernel/drivers/module-broadcom-wl/pspec.xml | 11 +- .../drivers/module-virtualbox-guest/pspec.xml | 13 +- kernel/drivers/module-virtualbox/pspec.xml | 13 +- kernel/drivers/ndiswrapper/pspec.xml | 11 +- .../files/patches/linux/patch-5.8.8.xz | Bin 0 -> 388708 bytes .../files/patches/mageia/aufs5.patch | 38152 ++++++++++++++++ kernel/tools/cpupowertools/pspec.xml | 15 +- 8 files changed, 38209 insertions(+), 17 deletions(-) create mode 100644 kernel/tools/cpupowertools/files/patches/linux/patch-5.8.8.xz create mode 100644 kernel/tools/cpupowertools/files/patches/mageia/aufs5.patch diff --git a/kernel/drivers/module-bbswitch/pspec.xml b/kernel/drivers/module-bbswitch/pspec.xml index 0dac26ac..26ff0b6d 100644 --- a/kernel/drivers/module-bbswitch/pspec.xml +++ b/kernel/drivers/module-bbswitch/pspec.xml @@ -13,7 +13,7 @@ Kernel module allowing to switch dedicated graphics card on Optimus laptops kernel module allowing to switch dedicated graphics card on Optimus laptops - kernel-module-headers + kernel-module-headers https://github.com/Bumblebee-Project/bbswitch/archive/v0.8.tar.gz @@ -24,7 +24,7 @@ module-bbswitch - kernel + kernel bbswitch-common @@ -62,6 +62,13 @@ + + 2020-09-10 + 0.8 + Rebuild + Mustafa Cinasal + muscnsl@gmail.com + 2020-08-05 0.8 diff --git a/kernel/drivers/module-broadcom-wl/pspec.xml b/kernel/drivers/module-broadcom-wl/pspec.xml index 91836b52..bd493b27 100755 --- a/kernel/drivers/module-broadcom-wl/pspec.xml +++ b/kernel/drivers/module-broadcom-wl/pspec.xml @@ -15,7 +15,7 @@ https://docs.broadcom.com/docs-and-downloads/docs/linux_sta/hybrid-v35-nodebug-pcoem-6_30_223_271.tar.gz https://docs.broadcom.com/docs-and-downloads/docs/linux_sta/hybrid-v35_64-nodebug-pcoem-6_30_223_271.tar.gz - kernel-module-headers + kernel-module-headers patch/license.patch @@ -33,7 +33,7 @@ module-broadcom-wl - kernel + kernel module-broadcom-wl-userspace @@ -62,6 +62,13 @@ + + 2020-09-10 + 6.30.223.271 + Rebuild. + Mustafa Cinasal + muscnsl@gmail.com + 2020-08-05 6.30.223.271 diff --git a/kernel/drivers/module-virtualbox-guest/pspec.xml b/kernel/drivers/module-virtualbox-guest/pspec.xml index b3a99d82..94a17752 100644 --- a/kernel/drivers/module-virtualbox-guest/pspec.xml +++ b/kernel/drivers/module-virtualbox-guest/pspec.xml @@ -12,9 +12,9 @@ driver Kernel modules for VirtualBox guest machines This package provides the kernel modules needed for mouse integration and shared folder support between VirtualBox host and guest systems. - https://sourceforge.net/projects/pisilinux/files/source/module-virtualbox-guest-6.1.12.tar.xz + https://sourceforge.net/projects/pisilinux/files/source/module-virtualbox-guest-6.1.14.tar.xz - kernel-module-headers + kernel-module-headers @@ -24,7 +24,7 @@ module-virtualbox-guest - kernel + kernel baselayout module-virtualbox-guest-userspace @@ -55,6 +55,13 @@ + + 2020-09-10 + 6.1.14 + Version bump. + Mustafa Cinasal + muscnsl@gmail.com + 2020-08-02 6.1.12 diff --git a/kernel/drivers/module-virtualbox/pspec.xml b/kernel/drivers/module-virtualbox/pspec.xml index c22df8da..a09d038d 100644 --- a/kernel/drivers/module-virtualbox/pspec.xml +++ b/kernel/drivers/module-virtualbox/pspec.xml @@ -12,9 +12,9 @@ driver Kernel modules for VirtualBox This package provides the kernel support for VirtualBox. - https://sourceforge.net/projects/pisilinux/files/source/module-virtualbox-6.1.12.tar.xz + https://sourceforge.net/projects/pisilinux/files/source/module-virtualbox-6.1.14.tar.xz - kernel-module-headers + kernel-module-headers @@ -45,7 +45,7 @@ module-ndiswrapper - kernel + kernel ndiswrapper-common @@ -77,6 +77,13 @@ + + 2020-09-10 + 1.63 + Version bump. + Mustafa Cinasal + muscnsl@gmail.com + 2020-08-05 1.63 diff --git a/kernel/tools/cpupowertools/files/patches/linux/patch-5.8.8.xz b/kernel/tools/cpupowertools/files/patches/linux/patch-5.8.8.xz new file mode 100644 index 0000000000000000000000000000000000000000..9d22cc902cb40bbb8e76460005598b9f2bf8661d GIT binary patch literal 388708 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ⅇJl?akyR-g#xdAe6VqL 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 z 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¥d#k$EdxKoX-tYswcK^*Di190 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 l6i^LC? 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/ ++Date: March 2009 ++Contact: J. R. Okajima ++Description: ++ Under /debug/aufs, a directory named si_ is created ++ per aufs mount, where is a unique id generated ++ internally. ++ ++What: /debug/aufs/si_/plink ++Date: Apr 2013 ++Contact: J. R. Okajima ++Description: ++ It has three lines and shows the information about the ++ pseudo-link. The first line is a single number ++ representing a number of buckets. The second line is a ++ number of pseudo-links per buckets (separated by a ++ blank). The last line is a single number representing a ++ total number of psedo-links. ++ When the aufs mount option 'noplink' is specified, it ++ will show "1\n0\n0\n". ++ ++What: /debug/aufs/si_/xib ++Date: March 2009 ++Contact: J. R. Okajima ++Description: ++ It shows the consumed blocks by xib (External Inode Number ++ Bitmap), its block size and file size. ++ When the aufs mount option 'noxino' is specified, it ++ will be empty. About XINO files, see the aufs manual. ++ ++What: /debug/aufs/si_/xi0, xi1 ... xiN and xiN-N ++Date: March 2009 ++Contact: J. R. Okajima ++Description: ++ It shows the consumed blocks by xino (External Inode Number ++ Translation Table), its link count, block size and file ++ size. ++ Due to the file size limit, there may exist multiple ++ xino files per branch. In this case, "-N" is added to ++ the filename and it corresponds to the index of the ++ internal xino array. "-0" is omitted. ++ When the aufs mount option 'noxino' is specified, Those ++ entries won't exist. About XINO files, see the aufs ++ manual. ++ ++What: /debug/aufs/si_/xigen ++Date: March 2009 ++Contact: J. R. Okajima ++Description: ++ It shows the consumed blocks by xigen (External Inode ++ Generation Table), its block size and file size. ++ If CONFIG_AUFS_EXPORT is disabled, this entry will not ++ be created. ++ When the aufs mount option 'noxino' is specified, it ++ will be empty. About XINO files, see the aufs manual. +diff --git a/Documentation/ABI/testing/sysfs-aufs b/Documentation/ABI/testing/sysfs-aufs +new file mode 100644 +index 000000000000..82f9518495ea +--- /dev/null ++++ b/Documentation/ABI/testing/sysfs-aufs +@@ -0,0 +1,31 @@ ++What: /sys/fs/aufs/si_/ ++Date: March 2009 ++Contact: J. R. Okajima ++Description: ++ Under /sys/fs/aufs, a directory named si_ is created ++ per aufs mount, where is a unique id generated ++ internally. ++ ++What: /sys/fs/aufs/si_/br0, br1 ... brN ++Date: March 2009 ++Contact: J. R. Okajima ++Description: ++ It shows the abolute path of a member directory (which ++ is called branch) in aufs, and its permission. ++ ++What: /sys/fs/aufs/si_/brid0, brid1 ... bridN ++Date: July 2013 ++Contact: J. R. Okajima ++Description: ++ It shows the id of a member directory (which is called ++ branch) in aufs. ++ ++What: /sys/fs/aufs/si_/xi_path ++Date: March 2009 ++Contact: J. R. Okajima ++Description: ++ It shows the abolute path of XINO (External Inode Number ++ Bitmap, Translation Table and Generation Table) file ++ even if it is the default path. ++ When the aufs mount option 'noxino' is specified, it ++ will be empty. About XINO files, see the aufs manual. +diff --git a/Documentation/filesystems/aufs/README b/Documentation/filesystems/aufs/README +new file mode 100644 +index 000000000000..3e655d357134 +--- /dev/null ++++ b/Documentation/filesystems/aufs/README +@@ -0,0 +1,401 @@ ++ ++Aufs5 -- advanced multi layered unification filesystem version 5.x ++http://aufs.sf.net ++Junjiro R. Okajima ++ ++ ++0. Introduction ++---------------------------------------- ++In the early days, aufs was entirely re-designed and re-implemented ++Unionfs Version 1.x series. Adding many original ideas, approaches, ++improvements and implementations, it became totally different from ++Unionfs while keeping the basic features. ++Later, Unionfs Version 2.x series began taking some of the same ++approaches to aufs1's. ++Unionfs was being developed by Professor Erez Zadok at Stony Brook ++University and his team. ++ ++Aufs5 supports linux-v5.0 and later, If you want older kernel version ++support, ++- for linux-v4.x series, try aufs4-linux.git or aufs4-standalone.git ++- for linux-v3.x series, try aufs3-linux.git or aufs3-standalone.git ++- for linux-v2.6.16 and later, try aufs2-2.6.git, aufs2-standalone.git ++ or aufs1 from CVS on SourceForge. ++ ++Note: it becomes clear that "Aufs was rejected. Let's give it up." ++ According to Christoph Hellwig, linux rejects all union-type ++ filesystems but UnionMount. ++ ++ ++PS. Al Viro seems have a plan to merge aufs as well as overlayfs and ++ UnionMount, and he pointed out an issue around a directory mutex ++ lock and aufs addressed it. But it is still unsure whether aufs will ++ be merged (or any other union solution). ++ ++ ++ ++1. Features ++---------------------------------------- ++- unite several directories into a single virtual filesystem. The member ++ directory is called as a branch. ++- you can specify the permission flags to the branch, which are 'readonly', ++ 'readwrite' and 'whiteout-able.' ++- by upper writable branch, internal copyup and whiteout, files/dirs on ++ readonly branch are modifiable logically. ++- dynamic branch manipulation, add, del. ++- etc... ++ ++Also there are many enhancements in aufs, such as: ++- test only the highest one for the directory permission (dirperm1) ++- copyup on open (coo=) ++- 'move' policy for copy-up between two writable branches, after ++ checking free space. ++- xattr, acl ++- readdir(3) in userspace. ++- keep inode number by external inode number table ++- keep the timestamps of file/dir in internal copyup operation ++- seekable directory, supporting NFS readdir. ++- whiteout is hardlinked in order to reduce the consumption of inodes ++ on branch ++- do not copyup, nor create a whiteout when it is unnecessary ++- revert a single systemcall when an error occurs in aufs ++- remount interface instead of ioctl ++- maintain /etc/mtab by an external command, /sbin/mount.aufs. ++- loopback mounted filesystem as a branch ++- kernel thread for removing the dir who has a plenty of whiteouts ++- support copyup sparse file (a file which has a 'hole' in it) ++- default permission flags for branches ++- selectable permission flags for ro branch, whether whiteout can ++ exist or not ++- export via NFS. ++- support /fs/aufs and /aufs. ++- support multiple writable branches, some policies to select one ++ among multiple writable branches. ++- a new semantics for link(2) and rename(2) to support multiple ++ writable branches. ++- no glibc changes are required. ++- pseudo hardlink (hardlink over branches) ++- allow a direct access manually to a file on branch, e.g. bypassing aufs. ++ including NFS or remote filesystem branch. ++- userspace wrapper for pathconf(3)/fpathconf(3) with _PC_LINK_MAX. ++- and more... ++ ++Currently these features are dropped temporary from aufs5. ++See design/08plan.txt in detail. ++- nested mount, i.e. aufs as readonly no-whiteout branch of another aufs ++ (robr) ++- statistics of aufs thread (/sys/fs/aufs/stat) ++ ++Features or just an idea in the future (see also design/*.txt), ++- reorder the branch index without del/re-add. ++- permanent xino files for NFSD ++- an option for refreshing the opened files after add/del branches ++- light version, without branch manipulation. (unnecessary?) ++- copyup in userspace ++- inotify in userspace ++- readv/writev ++ ++ ++2. Download ++---------------------------------------- ++There are three GIT trees for aufs5, aufs5-linux.git, ++aufs5-standalone.git, and aufs-util.git. Note that there is no "5" in ++"aufs-util.git." ++While the aufs-util is always necessary, you need either of aufs5-linux ++or aufs5-standalone. ++ ++The aufs5-linux tree includes the whole linux mainline GIT tree, ++git://git.kernel.org/.../torvalds/linux.git. ++And you cannot select CONFIG_AUFS_FS=m for this version, eg. you cannot ++build aufs5 as an external kernel module. ++Several extra patches are not included in this tree. Only ++aufs5-standalone tree contains them. They are described in the later ++section "Configuration and Compilation." ++ ++On the other hand, the aufs5-standalone tree has only aufs source files ++and necessary patches, and you can select CONFIG_AUFS_FS=m. ++But you need to apply all aufs patches manually. ++ ++You will find GIT branches whose name is in form of "aufs5.x" where "x" ++represents the linux kernel version, "linux-5.x". For instance, ++"aufs5.0" is for linux-5.0. For latest "linux-5.x-rcN", use ++"aufs5.x-rcN" branch. ++ ++o aufs5-linux tree ++$ git clone --reference /your/linux/git/tree \ ++ git://github.com/sfjro/aufs5-linux.git aufs5-linux.git ++- if you don't have linux GIT tree, then remove "--reference ..." ++$ cd aufs5-linux.git ++$ git checkout origin/aufs5.0 ++ ++Or You may want to directly git-pull aufs into your linux GIT tree, and ++leave the patch-work to GIT. ++$ cd /your/linux/git/tree ++$ git remote add aufs5 git://github.com/sfjro/aufs5-linux.git ++$ git fetch aufs5 ++$ git checkout -b my5.0 v5.0 ++$ (add your local change...) ++$ git pull aufs5 aufs5.0 ++- now you have v5.0 + your_changes + aufs5.0 in you my5.0 branch. ++- you may need to solve some conflicts between your_changes and ++ aufs5.0. in this case, git-rerere is recommended so that you can ++ solve the similar conflicts automatically when you upgrade to 5.1 or ++ later in the future. ++ ++o aufs5-standalone tree ++$ git clone git://github.com/sfjro/aufs5-standalone.git aufs5-standalone.git ++$ cd aufs5-standalone.git ++$ git checkout origin/aufs5.0 ++ ++o aufs-util tree ++$ git clone git://git.code.sf.net/p/aufs/aufs-util aufs-util.git ++- note that the public aufs-util.git is on SourceForge instead of ++ GitHUB. ++$ cd aufs-util.git ++$ git checkout origin/aufs5.0 ++ ++Note: The 5.x-rcN branch is to be used with `rc' kernel versions ONLY. ++The minor version number, 'x' in '5.x', of aufs may not always ++follow the minor version number of the kernel. ++Because changes in the kernel that cause the use of a new ++minor version number do not always require changes to aufs-util. ++ ++Since aufs-util has its own minor version number, you may not be ++able to find a GIT branch in aufs-util for your kernel's ++exact minor version number. ++In this case, you should git-checkout the branch for the ++nearest lower number. ++ ++For (an unreleased) example: ++If you are using "linux-5.10" and the "aufs5.10" branch ++does not exist in aufs-util repository, then "aufs5.9", "aufs5.8" ++or something numerically smaller is the branch for your kernel. ++ ++Also you can view all branches by ++ $ git branch -a ++ ++ ++3. Configuration and Compilation ++---------------------------------------- ++Make sure you have git-checkout'ed the correct branch. ++ ++For aufs5-linux tree, ++- enable CONFIG_AUFS_FS. ++- set other aufs configurations if necessary. ++ ++For aufs5-standalone tree, ++There are several ways to build. ++ ++1. ++- apply ./aufs5-kbuild.patch to your kernel source files. ++- apply ./aufs5-base.patch too. ++- apply ./aufs5-mmap.patch too. ++- apply ./aufs5-standalone.patch too, if you have a plan to set ++ CONFIG_AUFS_FS=m. otherwise you don't need ./aufs5-standalone.patch. ++- copy ./{Documentation,fs,include/uapi/linux/aufs_type.h} files to your ++ kernel source tree. Never copy $PWD/include/uapi/linux/Kbuild. ++- enable CONFIG_AUFS_FS, you can select either ++ =m or =y. ++- and build your kernel as usual. ++- install the built kernel. ++- install the header files too by "make headers_install" to the ++ directory where you specify. By default, it is $PWD/usr. ++ "make help" shows a brief note for headers_install. ++- and reboot your system. ++ ++2. ++- module only (CONFIG_AUFS_FS=m). ++- apply ./aufs5-base.patch to your kernel source files. ++- apply ./aufs5-mmap.patch too. ++- apply ./aufs5-standalone.patch too. ++- build your kernel, don't forget "make headers_install", and reboot. ++- edit ./config.mk and set other aufs configurations if necessary. ++ Note: You should read $PWD/fs/aufs/Kconfig carefully which describes ++ every aufs configurations. ++- build the module by simple "make". ++- you can specify ${KDIR} make variable which points to your kernel ++ source tree. ++- install the files ++ + run "make install" to install the aufs module, or copy the built ++ $PWD/aufs.ko to /lib/modules/... and run depmod -a (or reboot simply). ++ + run "make install_headers" (instead of headers_install) to install ++ the modified aufs header file (you can specify DESTDIR which is ++ available in aufs standalone version's Makefile only), or copy ++ $PWD/usr/include/linux/aufs_type.h to /usr/include/linux or wherever ++ you like manually. By default, the target directory is $PWD/usr. ++- no need to apply aufs5-kbuild.patch, nor copying source files to your ++ kernel source tree. ++ ++Note: The header file aufs_type.h is necessary to build aufs-util ++ as well as "make headers_install" in the kernel source tree. ++ headers_install is subject to be forgotten, but it is essentially ++ necessary, not only for building aufs-util. ++ You may not meet problems without headers_install in some older ++ version though. ++ ++And then, ++- read README in aufs-util, build and install it ++- note that your distribution may contain an obsoleted version of ++ aufs_type.h in /usr/include/linux or something. When you build aufs ++ utilities, make sure that your compiler refers the correct aufs header ++ file which is built by "make headers_install." ++- if you want to use readdir(3) in userspace or pathconf(3) wrapper, ++ then run "make install_ulib" too. And refer to the aufs manual in ++ detail. ++ ++There several other patches in aufs5-standalone.git. They are all ++optional. When you meet some problems, they will help you. ++- aufs5-loopback.patch ++ Supports a nested loopback mount in a branch-fs. This patch is ++ unnecessary until aufs produces a message like "you may want to try ++ another patch for loopback file". ++- proc_mounts.patch ++ When there are many mountpoints and many mount(2)/umount(2) are ++ running, then /proc/mounts may not show the all mountpoints. This ++ patch makes /proc/mounts always show the full mountpoints list. ++ If you don't want to apply this patch and meet such problem, then you ++ need to increase the value of 'ProcMounts_Times' make-variable in ++ aufs-util.git as a second best solution. ++- vfs-ino.patch ++ Modifies a system global kernel internal function get_next_ino() in ++ order to stop assigning 0 for an inode-number. Not directly related to ++ aufs, but recommended generally. ++- tmpfs-idr.patch ++ Keeps the tmpfs inode number as the lowest value. Effective to reduce ++ the size of aufs XINO files for tmpfs branch. Also it prevents the ++ duplication of inode number, which is important for backup tools and ++ other utilities. When you find aufs XINO files for tmpfs branch ++ growing too much, try this patch. ++- lockdep-debug.patch ++ Because aufs is not only an ordinary filesystem (callee of VFS), but ++ also a caller of VFS functions for branch filesystems, subclassing of ++ the internal locks for LOCKDEP is necessary. LOCKDEP is a debugging ++ feature of linux kernel. If you enable CONFIG_LOCKDEP, then you will ++ need to apply this debug patch to expand several constant values. ++ If you don't know what LOCKDEP is, then you don't have apply this ++ patch. ++ ++ ++4. Usage ++---------------------------------------- ++At first, make sure aufs-util are installed, and please read the aufs ++manual, aufs.5 in aufs-util.git tree. ++$ man -l aufs.5 ++ ++And then, ++$ mkdir /tmp/rw /tmp/aufs ++# mount -t aufs -o br=/tmp/rw:${HOME} none /tmp/aufs ++ ++Here is another example. The result is equivalent. ++# mount -t aufs -o br=/tmp/rw=rw:${HOME}=ro none /tmp/aufs ++ Or ++# mount -t aufs -o br:/tmp/rw none /tmp/aufs ++# mount -o remount,append:${HOME} /tmp/aufs ++ ++Then, you can see whole tree of your home dir through /tmp/aufs. If ++you modify a file under /tmp/aufs, the one on your home directory is ++not affected, instead the same named file will be newly created under ++/tmp/rw. And all of your modification to a file will be applied to ++the one under /tmp/rw. This is called the file based Copy on Write ++(COW) method. ++Aufs mount options are described in aufs.5. ++If you run chroot or something and make your aufs as a root directory, ++then you need to customize the shutdown script. See the aufs manual in ++detail. ++ ++Additionally, there are some sample usages of aufs which are a ++diskless system with network booting, and LiveCD over NFS. ++See sample dir in CVS tree on SourceForge. ++ ++ ++5. Contact ++---------------------------------------- ++When you have any problems or strange behaviour in aufs, please let me ++know with: ++- /proc/mounts (instead of the output of mount(8)) ++- /sys/module/aufs/* ++- /sys/fs/aufs/* (if you have them) ++- /debug/aufs/* (if you have them) ++- linux kernel version ++ if your kernel is not plain, for example modified by distributor, ++ the url where i can download its source is necessary too. ++- aufs version which was printed at loading the module or booting the ++ system, instead of the date you downloaded. ++- configuration (define/undefine CONFIG_AUFS_xxx) ++- kernel configuration or /proc/config.gz (if you have it) ++- LSM (linux security module, if you are using) ++- behaviour which you think to be incorrect ++- actual operation, reproducible one is better ++- mailto: aufs-users at lists.sourceforge.net ++ ++Usually, I don't watch the Public Areas(Bugs, Support Requests, Patches, ++and Feature Requests) on SourceForge. Please join and write to ++aufs-users ML. ++ ++ ++6. Acknowledgements ++---------------------------------------- ++Thanks to everyone who have tried and are using aufs, whoever ++have reported a bug or any feedback. ++ ++Especially donators: ++Tomas Matejicek(slax.org) made a donation (much more than once). ++ Since Apr 2010, Tomas M (the author of Slax and Linux Live ++ scripts) is making "doubling" donations. ++ Unfortunately I cannot list all of the donators, but I really ++ appreciate. ++ It ends Aug 2010, but the ordinary donation URL is still available. ++ ++Dai Itasaka made a donation (2007/8). ++Chuck Smith made a donation (2008/4, 10 and 12). ++Henk Schoneveld made a donation (2008/9). ++Chih-Wei Huang, ASUS, CTC donated Eee PC 4G (2008/10). ++Francois Dupoux made a donation (2008/11). ++Bruno Cesar Ribas and Luis Carlos Erpen de Bona, C3SL serves public ++ aufs2 GIT tree (2009/2). ++William Grant made a donation (2009/3). ++Patrick Lane made a donation (2009/4). ++The Mail Archive (mail-archive.com) made donations (2009/5). ++Nippy Networks (Ed Wildgoose) made a donation (2009/7). ++New Dream Network, LLC (www.dreamhost.com) made a donation (2009/11). ++Pavel Pronskiy made a donation (2011/2). ++Iridium and Inmarsat satellite phone retailer (www.mailasail.com), Nippy ++ Networks (Ed Wildgoose) made a donation for hardware (2011/3). ++Max Lekomcev (DOM-TV project) made a donation (2011/7, 12, 2012/3, 6 and ++11). ++Sam Liddicott made a donation (2011/9). ++Era Scarecrow made a donation (2013/4). ++Bor Ratajc made a donation (2013/4). ++Alessandro Gorreta made a donation (2013/4). ++POIRETTE Marc made a donation (2013/4). ++Alessandro Gorreta made a donation (2013/4). ++lauri kasvandik made a donation (2013/5). ++"pemasu from Finland" made a donation (2013/7). ++The Parted Magic Project made a donation (2013/9 and 11). ++Pavel Barta made a donation (2013/10). ++Nikolay Pertsev made a donation (2014/5). ++James B made a donation (2014/7 and 2015/7). ++Stefano Di Biase made a donation (2014/8). ++Daniel Epellei made a donation (2015/1). ++OmegaPhil made a donation (2016/1, 2018/4). ++Tomasz Szewczyk made a donation (2016/4). ++James Burry made a donation (2016/12). ++Carsten Rose made a donation (2018/9). ++Porteus Kiosk made a donation (2018/10). ++ ++Thank you very much. ++Donations are always, including future donations, very important and ++helpful for me to keep on developing aufs. ++ ++ ++7. ++---------------------------------------- ++If you are an experienced user, no explanation is needed. Aufs is ++just a linux filesystem. ++ ++ ++Enjoy! ++ ++# Local variables: ; ++# mode: text; ++# End: ; +diff --git a/Documentation/filesystems/aufs/design/01intro.txt b/Documentation/filesystems/aufs/design/01intro.txt +new file mode 100644 +index 000000000000..7f75ee4a784c +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/01intro.txt +@@ -0,0 +1,158 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++Introduction ++---------------------------------------- ++ ++aufs [ei ju: ef es] | /ey-yoo-ef-es/ | [a u f s] ++1. abbrev. for "advanced multi-layered unification filesystem". ++2. abbrev. for "another unionfs". ++3. abbrev. for "auf das" in German which means "on the" in English. ++ Ex. "Butter aufs Brot"(G) means "butter onto bread"(E). ++ But "Filesystem aufs Filesystem" is hard to understand. ++4. abbrev. for "African Urban Fashion Show". ++ ++AUFS is a filesystem with features: ++- multi layered stackable unification filesystem, the member directory ++ is called as a branch. ++- branch permission and attribute, 'readonly', 'real-readonly', ++ 'readwrite', 'whiteout-able', 'link-able whiteout', etc. and their ++ combination. ++- internal "file copy-on-write". ++- logical deletion, whiteout. ++- dynamic branch manipulation, adding, deleting and changing permission. ++- allow bypassing aufs, user's direct branch access. ++- external inode number translation table and bitmap which maintains the ++ persistent aufs inode number. ++- seekable directory, including NFS readdir. ++- file mapping, mmap and sharing pages. ++- pseudo-link, hardlink over branches. ++- loopback mounted filesystem as a branch. ++- several policies to select one among multiple writable branches. ++- revert a single systemcall when an error occurs in aufs. ++- and more... ++ ++ ++Multi Layered Stackable Unification Filesystem ++---------------------------------------------------------------------- ++Most people already knows what it is. ++It is a filesystem which unifies several directories and provides a ++merged single directory. When users access a file, the access will be ++passed/re-directed/converted (sorry, I am not sure which English word is ++correct) to the real file on the member filesystem. The member ++filesystem is called 'lower filesystem' or 'branch' and has a mode ++'readonly' and 'readwrite.' And the deletion for a file on the lower ++readonly branch is handled by creating 'whiteout' on the upper writable ++branch. ++ ++On LKML, there have been discussions about UnionMount (Jan Blunck, ++Bharata B Rao and Valerie Aurora) and Unionfs (Erez Zadok). They took ++different approaches to implement the merged-view. ++The former tries putting it into VFS, and the latter implements as a ++separate filesystem. ++(If I misunderstand about these implementations, please let me know and ++I shall correct it. Because it is a long time ago when I read their ++source files last time). ++ ++UnionMount's approach will be able to small, but may be hard to share ++branches between several UnionMount since the whiteout in it is ++implemented in the inode on branch filesystem and always ++shared. According to Bharata's post, readdir does not seems to be ++finished yet. ++There are several missing features known in this implementations such as ++- for users, the inode number may change silently. eg. copy-up. ++- link(2) may break by copy-up. ++- read(2) may get an obsoleted filedata (fstat(2) too). ++- fcntl(F_SETLK) may be broken by copy-up. ++- unnecessary copy-up may happen, for example mmap(MAP_PRIVATE) after ++ open(O_RDWR). ++ ++In linux-3.18, "overlay" filesystem (formerly known as "overlayfs") was ++merged into mainline. This is another implementation of UnionMount as a ++separated filesystem. All the limitations and known problems which ++UnionMount are equally inherited to "overlay" filesystem. ++ ++Unionfs has a longer history. When I started implementing a stackable ++filesystem (Aug 2005), it already existed. It has virtual super_block, ++inode, dentry and file objects and they have an array pointing lower ++same kind objects. After contributing many patches for Unionfs, I ++re-started my project AUFS (Jun 2006). ++ ++In AUFS, the structure of filesystem resembles to Unionfs, but I ++implemented my own ideas, approaches and enhancements and it became ++totally different one. ++ ++Comparing DM snapshot and fs based implementation ++- the number of bytes to be copied between devices is much smaller. ++- the type of filesystem must be one and only. ++- the fs must be writable, no readonly fs, even for the lower original ++ device. so the compression fs will not be usable. but if we use ++ loopback mount, we may address this issue. ++ for instance, ++ mount /cdrom/squashfs.img /sq ++ losetup /sq/ext2.img ++ losetup /somewhere/cow ++ dmsetup "snapshot /dev/loop0 /dev/loop1 ..." ++- it will be difficult (or needs more operations) to extract the ++ difference between the original device and COW. ++- DM snapshot-merge may help a lot when users try merging. in the ++ fs-layer union, users will use rsync(1). ++ ++You may want to read my old paper "Filesystems in LiveCD" ++(http://aufs.sourceforge.net/aufs2/report/sq/sq.pdf). ++ ++ ++Several characters/aspects/persona of aufs ++---------------------------------------------------------------------- ++ ++Aufs has several characters, aspects or persona. ++1. a filesystem, callee of VFS helper ++2. sub-VFS, caller of VFS helper for branches ++3. a virtual filesystem which maintains persistent inode number ++4. reader/writer of files on branches such like an application ++ ++1. Callee of VFS Helper ++As an ordinary linux filesystem, aufs is a callee of VFS. For instance, ++unlink(2) from an application reaches sys_unlink() kernel function and ++then vfs_unlink() is called. vfs_unlink() is one of VFS helper and it ++calls filesystem specific unlink operation. Actually aufs implements the ++unlink operation but it behaves like a redirector. ++ ++2. Caller of VFS Helper for Branches ++aufs_unlink() passes the unlink request to the branch filesystem as if ++it were called from VFS. So the called unlink operation of the branch ++filesystem acts as usual. As a caller of VFS helper, aufs should handle ++every necessary pre/post operation for the branch filesystem. ++- acquire the lock for the parent dir on a branch ++- lookup in a branch ++- revalidate dentry on a branch ++- mnt_want_write() for a branch ++- vfs_unlink() for a branch ++- mnt_drop_write() for a branch ++- release the lock on a branch ++ ++3. Persistent Inode Number ++One of the most important issue for a filesystem is to maintain inode ++numbers. This is particularly important to support exporting a ++filesystem via NFS. Aufs is a virtual filesystem which doesn't have a ++backend block device for its own. But some storage is necessary to ++keep and maintain the inode numbers. It may be a large space and may not ++suit to keep in memory. Aufs rents some space from its first writable ++branch filesystem (by default) and creates file(s) on it. These files ++are created by aufs internally and removed soon (currently) keeping ++opened. ++Note: Because these files are removed, they are totally gone after ++ unmounting aufs. It means the inode numbers are not persistent ++ across unmount or reboot. I have a plan to make them really ++ persistent which will be important for aufs on NFS server. ++ ++4. Read/Write Files Internally (copy-on-write) ++Because a branch can be readonly, when you write a file on it, aufs will ++"copy-up" it to the upper writable branch internally. And then write the ++originally requested thing to the file. Generally kernel doesn't ++open/read/write file actively. In aufs, even a single write may cause a ++internal "file copy". This behaviour is very similar to cp(1) command. ++ ++Some people may think it is better to pass such work to user space ++helper, instead of doing in kernel space. Actually I am still thinking ++about it. But currently I have implemented it in kernel space. +diff --git a/Documentation/filesystems/aufs/design/02struct.txt b/Documentation/filesystems/aufs/design/02struct.txt +new file mode 100644 +index 000000000000..0a948e812796 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/02struct.txt +@@ -0,0 +1,245 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++Basic Aufs Internal Structure ++ ++Superblock/Inode/Dentry/File Objects ++---------------------------------------------------------------------- ++As like an ordinary filesystem, aufs has its own ++superblock/inode/dentry/file objects. All these objects have a ++dynamically allocated array and store the same kind of pointers to the ++lower filesystem, branch. ++For example, when you build a union with one readwrite branch and one ++readonly, mounted /au, /rw and /ro respectively. ++- /au = /rw + /ro ++- /ro/fileA exists but /rw/fileA ++ ++Aufs lookup operation finds /ro/fileA and gets dentry for that. These ++pointers are stored in a aufs dentry. The array in aufs dentry will be, ++- [0] = NULL (because /rw/fileA doesn't exist) ++- [1] = /ro/fileA ++ ++This style of an array is essentially same to the aufs ++superblock/inode/dentry/file objects. ++ ++Because aufs supports manipulating branches, ie. add/delete/change ++branches dynamically, these objects has its own generation. When ++branches are changed, the generation in aufs superblock is ++incremented. And a generation in other object are compared when it is ++accessed. When a generation in other objects are obsoleted, aufs ++refreshes the internal array. ++ ++ ++Superblock ++---------------------------------------------------------------------- ++Additionally aufs superblock has some data for policies to select one ++among multiple writable branches, XIB files, pseudo-links and kobject. ++See below in detail. ++About the policies which supports copy-down a directory, see ++wbr_policy.txt too. ++ ++ ++Branch and XINO(External Inode Number Translation Table) ++---------------------------------------------------------------------- ++Every branch has its own xino (external inode number translation table) ++file. The xino file is created and unlinked by aufs internally. When two ++members of a union exist on the same filesystem, they share the single ++xino file. ++The struct of a xino file is simple, just a sequence of aufs inode ++numbers which is indexed by the lower inode number. ++In the above sample, assume the inode number of /ro/fileA is i111 and ++aufs assigns the inode number i999 for fileA. Then aufs writes 999 as ++4(8) bytes at 111 * 4(8) bytes offset in the xino file. ++ ++When the inode numbers are not contiguous, the xino file will be sparse ++which has a hole in it and doesn't consume as much disk space as it ++might appear. If your branch filesystem consumes disk space for such ++holes, then you should specify 'xino=' option at mounting aufs. ++ ++Aufs has a mount option to free the disk blocks for such holes in XINO ++files on tmpfs or ramdisk. But it is not so effective actually. If you ++meet a problem of disk shortage due to XINO files, then you should try ++"tmpfs-ino.patch" (and "vfs-ino.patch" too) in aufs4-standalone.git. ++The patch localizes the assignment inumbers per tmpfs-mount and avoid ++the holes in XINO files. ++ ++Also a writable branch has three kinds of "whiteout bases". All these ++are existed when the branch is joined to aufs, and their names are ++whiteout-ed doubly, so that users will never see their names in aufs ++hierarchy. ++1. a regular file which will be hardlinked to all whiteouts. ++2. a directory to store a pseudo-link. ++3. a directory to store an "orphan"-ed file temporary. ++ ++1. Whiteout Base ++ When you remove a file on a readonly branch, aufs handles it as a ++ logical deletion and creates a whiteout on the upper writable branch ++ as a hardlink of this file in order not to consume inode on the ++ writable branch. ++2. Pseudo-link Dir ++ See below, Pseudo-link. ++3. Step-Parent Dir ++ When "fileC" exists on the lower readonly branch only and it is ++ opened and removed with its parent dir, and then user writes ++ something into it, then aufs copies-up fileC to this ++ directory. Because there is no other dir to store fileC. After ++ creating a file under this dir, the file is unlinked. ++ ++Because aufs supports manipulating branches, ie. add/delete/change ++dynamically, a branch has its own id. When the branch order changes, ++aufs finds the new index by searching the branch id. ++ ++ ++Pseudo-link ++---------------------------------------------------------------------- ++Assume "fileA" exists on the lower readonly branch only and it is ++hardlinked to "fileB" on the branch. When you write something to fileA, ++aufs copies-up it to the upper writable branch. Additionally aufs ++creates a hardlink under the Pseudo-link Directory of the writable ++branch. The inode of a pseudo-link is kept in aufs super_block as a ++simple list. If fileB is read after unlinking fileA, aufs returns ++filedata from the pseudo-link instead of the lower readonly ++branch. Because the pseudo-link is based upon the inode, to keep the ++inode number by xino (see above) is essentially necessary. ++ ++All the hardlinks under the Pseudo-link Directory of the writable branch ++should be restored in a proper location later. Aufs provides a utility ++to do this. The userspace helpers executed at remounting and unmounting ++aufs by default. ++During this utility is running, it puts aufs into the pseudo-link ++maintenance mode. In this mode, only the process which began the ++maintenance mode (and its child processes) is allowed to operate in ++aufs. Some other processes which are not related to the pseudo-link will ++be allowed to run too, but the rest have to return an error or wait ++until the maintenance mode ends. If a process already acquires an inode ++mutex (in VFS), it has to return an error. ++ ++ ++XIB(external inode number bitmap) ++---------------------------------------------------------------------- ++Addition to the xino file per a branch, aufs has an external inode number ++bitmap in a superblock object. It is also an internal file such like a ++xino file. ++It is a simple bitmap to mark whether the aufs inode number is in-use or ++not. ++To reduce the file I/O, aufs prepares a single memory page to cache xib. ++ ++As well as XINO files, aufs has a feature to truncate/refresh XIB to ++reduce the number of consumed disk blocks for these files. ++ ++ ++Virtual or Vertical Dir, and Readdir in Userspace ++---------------------------------------------------------------------- ++In order to support multiple layers (branches), aufs readdir operation ++constructs a virtual dir block on memory. For readdir, aufs calls ++vfs_readdir() internally for each dir on branches, merges their entries ++with eliminating the whiteout-ed ones, and sets it to file (dir) ++object. So the file object has its entry list until it is closed. The ++entry list will be updated when the file position is zero and becomes ++obsoleted. This decision is made in aufs automatically. ++ ++The dynamically allocated memory block for the name of entries has a ++unit of 512 bytes (by default) and stores the names contiguously (no ++padding). Another block for each entry is handled by kmem_cache too. ++During building dir blocks, aufs creates hash list and judging whether ++the entry is whiteouted by its upper branch or already listed. ++The merged result is cached in the corresponding inode object and ++maintained by a customizable life-time option. ++ ++Some people may call it can be a security hole or invite DoS attack ++since the opened and once readdir-ed dir (file object) holds its entry ++list and becomes a pressure for system memory. But I'd say it is similar ++to files under /proc or /sys. The virtual files in them also holds a ++memory page (generally) while they are opened. When an idea to reduce ++memory for them is introduced, it will be applied to aufs too. ++For those who really hate this situation, I've developed readdir(3) ++library which operates this merging in userspace. You just need to set ++LD_PRELOAD environment variable, and aufs will not consume no memory in ++kernel space for readdir(3). ++ ++ ++Workqueue ++---------------------------------------------------------------------- ++Aufs sometimes requires privilege access to a branch. For instance, ++in copy-up/down operation. When a user process is going to make changes ++to a file which exists in the lower readonly branch only, and the mode ++of one of ancestor directories may not be writable by a user ++process. Here aufs copy-up the file with its ancestors and they may ++require privilege to set its owner/group/mode/etc. ++This is a typical case of a application character of aufs (see ++Introduction). ++ ++Aufs uses workqueue synchronously for this case. It creates its own ++workqueue. The workqueue is a kernel thread and has privilege. Aufs ++passes the request to call mkdir or write (for example), and wait for ++its completion. This approach solves a problem of a signal handler ++simply. ++If aufs didn't adopt the workqueue and changed the privilege of the ++process, then the process may receive the unexpected SIGXFSZ or other ++signals. ++ ++Also aufs uses the system global workqueue ("events" kernel thread) too ++for asynchronous tasks, such like handling inotify/fsnotify, re-creating a ++whiteout base and etc. This is unrelated to a privilege. ++Most of aufs operation tries acquiring a rw_semaphore for aufs ++superblock at the beginning, at the same time waits for the completion ++of all queued asynchronous tasks. ++ ++ ++Whiteout ++---------------------------------------------------------------------- ++The whiteout in aufs is very similar to Unionfs's. That is represented ++by its filename. UnionMount takes an approach of a file mode, but I am ++afraid several utilities (find(1) or something) will have to support it. ++ ++Basically the whiteout represents "logical deletion" which stops aufs to ++lookup further, but also it represents "dir is opaque" which also stop ++further lookup. ++ ++In aufs, rmdir(2) and rename(2) for dir uses whiteout alternatively. ++In order to make several functions in a single systemcall to be ++revertible, aufs adopts an approach to rename a directory to a temporary ++unique whiteouted name. ++For example, in rename(2) dir where the target dir already existed, aufs ++renames the target dir to a temporary unique whiteouted name before the ++actual rename on a branch, and then handles other actions (make it opaque, ++update the attributes, etc). If an error happens in these actions, aufs ++simply renames the whiteouted name back and returns an error. If all are ++succeeded, aufs registers a function to remove the whiteouted unique ++temporary name completely and asynchronously to the system global ++workqueue. ++ ++ ++Copy-up ++---------------------------------------------------------------------- ++It is a well-known feature or concept. ++When user modifies a file on a readonly branch, aufs operate "copy-up" ++internally and makes change to the new file on the upper writable branch. ++When the trigger systemcall does not update the timestamps of the parent ++dir, aufs reverts it after copy-up. ++ ++ ++Move-down (aufs3.9 and later) ++---------------------------------------------------------------------- ++"Copy-up" is one of the essential feature in aufs. It copies a file from ++the lower readonly branch to the upper writable branch when a user ++changes something about the file. ++"Move-down" is an opposite action of copy-up. Basically this action is ++ran manually instead of automatically and internally. ++For desgin and implementation, aufs has to consider these issues. ++- whiteout for the file may exist on the lower branch. ++- ancestor directories may not exist on the lower branch. ++- diropq for the ancestor directories may exist on the upper branch. ++- free space on the lower branch will reduce. ++- another access to the file may happen during moving-down, including ++ UDBA (see "Revalidate Dentry and UDBA"). ++- the file should not be hard-linked nor pseudo-linked. they should be ++ handled by auplink utility later. ++ ++Sometimes users want to move-down a file from the upper writable branch ++to the lower readonly or writable branch. For instance, ++- the free space of the upper writable branch is going to run out. ++- create a new intermediate branch between the upper and lower branch. ++- etc. ++ ++For this purpose, use "aumvdown" command in aufs-util.git. +diff --git a/Documentation/filesystems/aufs/design/03atomic_open.txt b/Documentation/filesystems/aufs/design/03atomic_open.txt +new file mode 100644 +index 000000000000..415205649c4c +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/03atomic_open.txt +@@ -0,0 +1,72 @@ ++ ++# Copyright (C) 2015-2020 Junjiro R. Okajima ++ ++Support for a branch who has its ->atomic_open() ++---------------------------------------------------------------------- ++The filesystems who implement its ->atomic_open() are not majority. For ++example NFSv4 does, and aufs should call NFSv4 ->atomic_open, ++particularly for open(O_CREAT|O_EXCL, 0400) case. Other than ++->atomic_open(), NFSv4 returns an error for this open(2). While I am not ++sure whether all filesystems who have ->atomic_open() behave like this, ++but NFSv4 surely returns the error. ++ ++In order to support ->atomic_open() for aufs, there are a few ++approaches. ++ ++A. Introduce aufs_atomic_open() ++ - calls one of VFS:do_last(), lookup_open() or atomic_open() for ++ branch fs. ++B. Introduce aufs_atomic_open() calling create, open and chmod. this is ++ an aufs user Pip Cet's approach ++ - calls aufs_create(), VFS finish_open() and notify_change(). ++ - pass fake-mode to finish_open(), and then correct the mode by ++ notify_change(). ++C. Extend aufs_open() to call branch fs's ->atomic_open() ++ - no aufs_atomic_open(). ++ - aufs_lookup() registers the TID to an aufs internal object. ++ - aufs_create() does nothing when the matching TID is registered, but ++ registers the mode. ++ - aufs_open() calls branch fs's ->atomic_open() when the matching ++ TID is registered. ++D. Extend aufs_open() to re-try branch fs's ->open() with superuser's ++ credential ++ - no aufs_atomic_open(). ++ - aufs_create() registers the TID to an internal object. this info ++ represents "this process created this file just now." ++ - when aufs gets EACCES from branch fs's ->open(), then confirm the ++ registered TID and re-try open() with superuser's credential. ++ ++Pros and cons for each approach. ++ ++A. ++ - straightforward but highly depends upon VFS internal. ++ - the atomic behavaiour is kept. ++ - some of parameters such as nameidata are hard to reproduce for ++ branch fs. ++ - large overhead. ++B. ++ - easy to implement. ++ - the atomic behavaiour is lost. ++C. ++ - the atomic behavaiour is kept. ++ - dirty and tricky. ++ - VFS checks whether the file is created correctly after calling ++ ->create(), which means this approach doesn't work. ++D. ++ - easy to implement. ++ - the atomic behavaiour is lost. ++ - to open a file with superuser's credential and give it to a user ++ process is a bad idea, since the file object keeps the credential ++ in it. It may affect LSM or something. This approach doesn't work ++ either. ++ ++The approach A is ideal, but it hard to implement. So here is a ++variation of A, which is to be implemented. ++ ++A-1. Introduce aufs_atomic_open() ++ - calls branch fs ->atomic_open() if exists. otherwise calls ++ vfs_create() and finish_open(). ++ - the demerit is that the several checks after branch fs ++ ->atomic_open() are lost. in the ordinary case, the checks are ++ done by VFS:do_last(), lookup_open() and atomic_open(). some can ++ be implemented in aufs, but not all I am afraid. +diff --git a/Documentation/filesystems/aufs/design/03lookup.txt b/Documentation/filesystems/aufs/design/03lookup.txt +new file mode 100644 +index 000000000000..0b3b22bc999f +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/03lookup.txt +@@ -0,0 +1,100 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++Lookup in a Branch ++---------------------------------------------------------------------- ++Since aufs has a character of sub-VFS (see Introduction), it operates ++lookup for branches as VFS does. It may be a heavy work. But almost all ++lookup operation in aufs is the simplest case, ie. lookup only an entry ++directly connected to its parent. Digging down the directory hierarchy ++is unnecessary. VFS has a function lookup_one_len() for that use, and ++aufs calls it. ++ ++When a branch is a remote filesystem, aufs basically relies upon its ++->d_revalidate(), also aufs forces the hardest revalidate tests for ++them. ++For d_revalidate, aufs implements three levels of revalidate tests. See ++"Revalidate Dentry and UDBA" in detail. ++ ++ ++Test Only the Highest One for the Directory Permission (dirperm1 option) ++---------------------------------------------------------------------- ++Let's try case study. ++- aufs has two branches, upper readwrite and lower readonly. ++ /au = /rw + /ro ++- "dirA" exists under /ro, but /rw. and its mode is 0700. ++- user invoked "chmod a+rx /au/dirA" ++- the internal copy-up is activated and "/rw/dirA" is created and its ++ permission bits are set to world readable. ++- then "/au/dirA" becomes world readable? ++ ++In this case, /ro/dirA is still 0700 since it exists in readonly branch, ++or it may be a natively readonly filesystem. If aufs respects the lower ++branch, it should not respond readdir request from other users. But user ++allowed it by chmod. Should really aufs rejects showing the entries ++under /ro/dirA? ++ ++To be honest, I don't have a good solution for this case. So aufs ++implements 'dirperm1' and 'nodirperm1' mount options, and leave it to ++users. ++When dirperm1 is specified, aufs checks only the highest one for the ++directory permission, and shows the entries. Otherwise, as usual, checks ++every dir existing on all branches and rejects the request. ++ ++As a side effect, dirperm1 option improves the performance of aufs ++because the number of permission check is reduced when the number of ++branch is many. ++ ++ ++Revalidate Dentry and UDBA (User's Direct Branch Access) ++---------------------------------------------------------------------- ++Generally VFS helpers re-validate a dentry as a part of lookup. ++0. digging down the directory hierarchy. ++1. lock the parent dir by its i_mutex. ++2. lookup the final (child) entry. ++3. revalidate it. ++4. call the actual operation (create, unlink, etc.) ++5. unlock the parent dir ++ ++If the filesystem implements its ->d_revalidate() (step 3), then it is ++called. Actually aufs implements it and checks the dentry on a branch is ++still valid. ++But it is not enough. Because aufs has to release the lock for the ++parent dir on a branch at the end of ->lookup() (step 2) and ++->d_revalidate() (step 3) while the i_mutex of the aufs dir is still ++held by VFS. ++If the file on a branch is changed directly, eg. bypassing aufs, after ++aufs released the lock, then the subsequent operation may cause ++something unpleasant result. ++ ++This situation is a result of VFS architecture, ->lookup() and ++->d_revalidate() is separated. But I never say it is wrong. It is a good ++design from VFS's point of view. It is just not suitable for sub-VFS ++character in aufs. ++ ++Aufs supports such case by three level of revalidation which is ++selectable by user. ++1. Simple Revalidate ++ Addition to the native flow in VFS's, confirm the child-parent ++ relationship on the branch just after locking the parent dir on the ++ branch in the "actual operation" (step 4). When this validation ++ fails, aufs returns EBUSY. ->d_revalidate() (step 3) in aufs still ++ checks the validation of the dentry on branches. ++2. Monitor Changes Internally by Inotify/Fsnotify ++ Addition to above, in the "actual operation" (step 4) aufs re-lookup ++ the dentry on the branch, and returns EBUSY if it finds different ++ dentry. ++ Additionally, aufs sets the inotify/fsnotify watch for every dir on branches ++ during it is in cache. When the event is notified, aufs registers a ++ function to kernel 'events' thread by schedule_work(). And the ++ function sets some special status to the cached aufs dentry and inode ++ private data. If they are not cached, then aufs has nothing to ++ do. When the same file is accessed through aufs (step 0-3) later, ++ aufs will detect the status and refresh all necessary data. ++ In this mode, aufs has to ignore the event which is fired by aufs ++ itself. ++3. No Extra Validation ++ This is the simplest test and doesn't add any additional revalidation ++ test, and skip the revalidation in step 4. It is useful and improves ++ aufs performance when system surely hide the aufs branches from user, ++ by over-mounting something (or another method). +diff --git a/Documentation/filesystems/aufs/design/04branch.txt b/Documentation/filesystems/aufs/design/04branch.txt +new file mode 100644 +index 000000000000..0e7bc1075f37 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/04branch.txt +@@ -0,0 +1,61 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++Branch Manipulation ++ ++Since aufs supports dynamic branch manipulation, ie. add/remove a branch ++and changing its permission/attribute, there are a lot of works to do. ++ ++ ++Add a Branch ++---------------------------------------------------------------------- ++o Confirm the adding dir exists outside of aufs, including loopback ++ mount, and its various attributes. ++o Initialize the xino file and whiteout bases if necessary. ++ See struct.txt. ++ ++o Check the owner/group/mode of the directory ++ When the owner/group/mode of the adding directory differs from the ++ existing branch, aufs issues a warning because it may impose a ++ security risk. ++ For example, when a upper writable branch has a world writable empty ++ top directory, a malicious user can create any files on the writable ++ branch directly, like copy-up and modify manually. If something like ++ /etc/{passwd,shadow} exists on the lower readonly branch but the upper ++ writable branch, and the writable branch is world-writable, then a ++ malicious guy may create /etc/passwd on the writable branch directly ++ and the infected file will be valid in aufs. ++ I am afraid it can be a security issue, but aufs can do nothing except ++ producing a warning. ++ ++ ++Delete a Branch ++---------------------------------------------------------------------- ++o Confirm the deleting branch is not busy ++ To be general, there is one merit to adopt "remount" interface to ++ manipulate branches. It is to discard caches. At deleting a branch, ++ aufs checks the still cached (and connected) dentries and inodes. If ++ there are any, then they are all in-use. An inode without its ++ corresponding dentry can be alive alone (for example, inotify/fsnotify case). ++ ++ For the cached one, aufs checks whether the same named entry exists on ++ other branches. ++ If the cached one is a directory, because aufs provides a merged view ++ to users, as long as one dir is left on any branch aufs can show the ++ dir to users. In this case, the branch can be removed from aufs. ++ Otherwise aufs rejects deleting the branch. ++ ++ If any file on the deleting branch is opened by aufs, then aufs ++ rejects deleting. ++ ++ ++Modify the Permission of a Branch ++---------------------------------------------------------------------- ++o Re-initialize or remove the xino file and whiteout bases if necessary. ++ See struct.txt. ++ ++o rw --> ro: Confirm the modifying branch is not busy ++ Aufs rejects the request if any of these conditions are true. ++ - a file on the branch is mmap-ed. ++ - a regular file on the branch is opened for write and there is no ++ same named entry on the upper branch. +diff --git a/Documentation/filesystems/aufs/design/05wbr_policy.txt b/Documentation/filesystems/aufs/design/05wbr_policy.txt +new file mode 100644 +index 000000000000..f9741c32cbf2 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/05wbr_policy.txt +@@ -0,0 +1,51 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++Policies to Select One among Multiple Writable Branches ++---------------------------------------------------------------------- ++When the number of writable branch is more than one, aufs has to decide ++the target branch for file creation or copy-up. By default, the highest ++writable branch which has the parent (or ancestor) dir of the target ++file is chosen (top-down-parent policy). ++By user's request, aufs implements some other policies to select the ++writable branch, for file creation several policies, round-robin, ++most-free-space, and other policies. For copy-up, top-down-parent, ++bottom-up-parent, bottom-up and others. ++ ++As expected, the round-robin policy selects the branch in circular. When ++you have two writable branches and creates 10 new files, 5 files will be ++created for each branch. mkdir(2) systemcall is an exception. When you ++create 10 new directories, all will be created on the same branch. ++And the most-free-space policy selects the one which has most free ++space among the writable branches. The amount of free space will be ++checked by aufs internally, and users can specify its time interval. ++ ++The policies for copy-up is more simple, ++top-down-parent is equivalent to the same named on in create policy, ++bottom-up-parent selects the writable branch where the parent dir ++exists and the nearest upper one from the copyup-source, ++bottom-up selects the nearest upper writable branch from the ++copyup-source, regardless the existence of the parent dir. ++ ++There are some rules or exceptions to apply these policies. ++- If there is a readonly branch above the policy-selected branch and ++ the parent dir is marked as opaque (a variation of whiteout), or the ++ target (creating) file is whiteout-ed on the upper readonly branch, ++ then the result of the policy is ignored and the target file will be ++ created on the nearest upper writable branch than the readonly branch. ++- If there is a writable branch above the policy-selected branch and ++ the parent dir is marked as opaque or the target file is whiteouted ++ on the branch, then the result of the policy is ignored and the target ++ file will be created on the highest one among the upper writable ++ branches who has diropq or whiteout. In case of whiteout, aufs removes ++ it as usual. ++- link(2) and rename(2) systemcalls are exceptions in every policy. ++ They try selecting the branch where the source exists as possible ++ since copyup a large file will take long time. If it can't be, ++ ie. the branch where the source exists is readonly, then they will ++ follow the copyup policy. ++- There is an exception for rename(2) when the target exists. ++ If the rename target exists, aufs compares the index of the branches ++ where the source and the target exists and selects the higher ++ one. If the selected branch is readonly, then aufs follows the ++ copyup policy. +diff --git a/Documentation/filesystems/aufs/design/06dirren.dot b/Documentation/filesystems/aufs/design/06dirren.dot +new file mode 100644 +index 000000000000..2d62bb6dd55f +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/06dirren.dot +@@ -0,0 +1,31 @@ ++ ++// to view this graph, run dot(1) command in GRAPHVIZ. ++ ++digraph G { ++node [shape=box]; ++whinfo [label="detailed info file\n(lower_brid_root-hinum, h_inum, namelen, old name)"]; ++ ++node [shape=oval]; ++ ++aufs_rename -> whinfo [label="store/remove"]; ++ ++node [shape=oval]; ++inode_list [label="h_inum list in branch\ncache"]; ++ ++node [shape=box]; ++whinode [label="h_inum list file"]; ++ ++node [shape=oval]; ++brmgmt [label="br_add/del/mod/umount"]; ++ ++brmgmt -> inode_list [label="create/remove"]; ++brmgmt -> whinode [label="load/store"]; ++ ++inode_list -> whinode [style=dashed,dir=both]; ++ ++aufs_rename -> inode_list [label="add/del"]; ++ ++aufs_lookup -> inode_list [label="search"]; ++ ++aufs_lookup -> whinfo [label="load/remove"]; ++} +diff --git a/Documentation/filesystems/aufs/design/06dirren.txt b/Documentation/filesystems/aufs/design/06dirren.txt +new file mode 100644 +index 000000000000..e23459758504 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/06dirren.txt +@@ -0,0 +1,89 @@ ++ ++# Copyright (C) 2017-2020 Junjiro R. Okajima ++ ++Special handling for renaming a directory (DIRREN) ++---------------------------------------------------------------------- ++First, let's assume we have a simple usecase. ++ ++- /u = /rw + /ro ++- /rw/dirA exists ++- /ro/dirA and /ro/dirA/file exist too ++- there is no dirB on both branches ++- a user issues rename("dirA", "dirB") ++ ++Now, what should aufs behave against this rename(2)? ++There are a few possible cases. ++ ++A. returns EROFS. ++ since dirA exists on a readonly branch which cannot be renamed. ++B. returns EXDEV. ++ it is possible to copy-up dirA (only the dir itself), but the child ++ entries ("file" in this case) should not be. it must be a bad ++ approach to copy-up recursively. ++C. returns a success. ++ even the branch /ro is readonly, aufs tries renaming it. Obviously it ++ is a violation of aufs' policy. ++D. construct an extra information which indicates that /ro/dirA should ++ be handled as the name of dirB. ++ overlayfs has a similar feature called REDIRECT. ++ ++Until now, aufs implements the case B only which returns EXDEV, and ++expects the userspace application behaves like mv(1) which tries ++issueing rename(2) recursively. ++ ++A new aufs feature called DIRREN is introduced which implements the case ++D. There are several "extra information" added. ++ ++1. detailed info per renamed directory ++ path: /rw/dirB/$AUFS_WH_DR_INFO_PFX. ++2. the inode-number list of directories on a branch ++ path: /rw/dirB/$AUFS_WH_DR_BRHINO ++ ++The filename of "detailed info per directory" represents the lower ++branch, and its format is ++- a type of the branch id ++ one of these. ++ + uuid (not implemented yet) ++ + fsid ++ + dev ++- the inode-number of the branch root dir ++ ++And it contains these info in a single regular file. ++- magic number ++- branch's inode-number of the logically renamed dir ++- the name of the before-renamed dir ++ ++The "detailed info per directory" file is created in aufs rename(2), and ++loaded in any lookup. ++The info is considered in lookup for the matching case only. Here ++"matching" means that the root of branch (in the info filename) is same ++to the current looking-up branch. After looking-up the before-renamed ++name, the inode-number is compared. And the matched dentry is used. ++ ++The "inode-number list of directories" is a regular file which contains ++simply the inode-numbers on the branch. The file is created or updated ++in removing the branch, and loaded in adding the branch. Its lifetime is ++equal to the branch. ++The list is refered in lookup, and when the current target inode is ++found in the list, the aufs tries loading the "detailed info per ++directory" and get the changed and valid name of the dir. ++ ++Theoretically these "extra informaiton" may be able to be put into XATTR ++in the dir inode. But aufs doesn't choose this way because ++1. XATTR may not be supported by the branch (or its configuration) ++2. XATTR may have its size limit. ++3. XATTR may be less easy to convert than a regular file, when the ++ format of the info is changed in the future. ++At the same time, I agree that the regular file approach is much slower ++than XATTR approach. So, in the future, aufs may take the XATTR or other ++better approach. ++ ++This DIRREN feature is enabled by aufs configuration, and is activated ++by a new mount option. ++ ++For the more complicated case, there is a work with UDBA option, which ++is to dected the direct access to the branches (by-passing aufs) and to ++maintain the cashes in aufs. Since a single cached aufs dentry may ++contains two names, before- and after-rename, the name comparision in ++UDBA handler may not work correctly. In this case, the behaviour will be ++equivalen to udba=reval case. +diff --git a/Documentation/filesystems/aufs/design/06fhsm.txt b/Documentation/filesystems/aufs/design/06fhsm.txt +new file mode 100644 +index 000000000000..5322ca3b7151 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/06fhsm.txt +@@ -0,0 +1,105 @@ ++ ++# Copyright (C) 2011-2020 Junjiro R. Okajima ++ ++File-based Hierarchical Storage Management (FHSM) ++---------------------------------------------------------------------- ++Hierarchical Storage Management (or HSM) is a well-known feature in the ++storage world. Aufs provides this feature as file-based with multiple ++writable branches, based upon the principle of "Colder, the Lower". ++Here the word "colder" means that the less used files, and "lower" means ++that the position in the order of the stacked branches vertically. ++These multiple writable branches are prioritized, ie. the topmost one ++should be the fastest drive and be used heavily. ++ ++o Characters in aufs FHSM story ++- aufs itself and a new branch attribute. ++- a new ioctl interface to move-down and to establish a connection with ++ the daemon ("move-down" is a converse of "copy-up"). ++- userspace tool and daemon. ++ ++The userspace daemon establishes a connection with aufs and waits for ++the notification. The notified information is very similar to struct ++statfs containing the number of consumed blocks and inodes. ++When the consumed blocks/inodes of a branch exceeds the user-specified ++upper watermark, the daemon activates its move-down process until the ++consumed blocks/inodes reaches the user-specified lower watermark. ++ ++The actual move-down is done by aufs based upon the request from ++user-space since we need to maintain the inode number and the internal ++pointer arrays in aufs. ++ ++Currently aufs FHSM handles the regular files only. Additionally they ++must not be hard-linked nor pseudo-linked. ++ ++ ++o Cowork of aufs and the user-space daemon ++ During the userspace daemon established the connection, aufs sends a ++ small notification to it whenever aufs writes something into the ++ writable branch. But it may cost high since aufs issues statfs(2) ++ internally. So user can specify a new option to cache the ++ info. Actually the notification is controlled by these factors. ++ + the specified cache time. ++ + classified as "force" by aufs internally. ++ Until the specified time expires, aufs doesn't send the info ++ except the forced cases. When aufs decide forcing, the info is always ++ notified to userspace. ++ For example, the number of free inodes is generally large enough and ++ the shortage of it happens rarely. So aufs doesn't force the ++ notification when creating a new file, directory and others. This is ++ the typical case which aufs doesn't force. ++ When aufs writes the actual filedata and the files consumes any of new ++ blocks, the aufs forces notifying. ++ ++ ++o Interfaces in aufs ++- New branch attribute. ++ + fhsm ++ Specifies that the branch is managed by FHSM feature. In other word, ++ participant in the FHSM. ++ When nofhsm is set to the branch, it will not be the source/target ++ branch of the move-down operation. This attribute is set ++ independently from coo and moo attributes, and if you want full ++ FHSM, you should specify them as well. ++- New mount option. ++ + fhsm_sec ++ Specifies a second to suppress many less important info to be ++ notified. ++- New ioctl. ++ + AUFS_CTL_FHSM_FD ++ create a new file descriptor which userspace can read the notification ++ (a subset of struct statfs) from aufs. ++- Module parameter 'brs' ++ It has to be set to 1. Otherwise the new mount option 'fhsm' will not ++ be set. ++- mount helpers /sbin/mount.aufs and /sbin/umount.aufs ++ When there are two or more branches with fhsm attributes, ++ /sbin/mount.aufs invokes the user-space daemon and /sbin/umount.aufs ++ terminates it. As a result of remounting and branch-manipulation, the ++ number of branches with fhsm attribute can be one. In this case, ++ /sbin/mount.aufs will terminate the user-space daemon. ++ ++ ++Finally the operation is done as these steps in kernel-space. ++- make sure that, ++ + no one else is using the file. ++ + the file is not hard-linked. ++ + the file is not pseudo-linked. ++ + the file is a regular file. ++ + the parent dir is not opaqued. ++- find the target writable branch. ++- make sure the file is not whiteout-ed by the upper (than the target) ++ branch. ++- make the parent dir on the target branch. ++- mutex lock the inode on the branch. ++- unlink the whiteout on the target branch (if exists). ++- lookup and create the whiteout-ed temporary name on the target branch. ++- copy the file as the whiteout-ed temporary name on the target branch. ++- rename the whiteout-ed temporary name to the original name. ++- unlink the file on the source branch. ++- maintain the internal pointer array and the external inode number ++ table (XINO). ++- maintain the timestamps and other attributes of the parent dir and the ++ file. ++ ++And of course, in every step, an error may happen. So the operation ++should restore the original file state after an error happens. +diff --git a/Documentation/filesystems/aufs/design/06mmap.txt b/Documentation/filesystems/aufs/design/06mmap.txt +new file mode 100644 +index 000000000000..03b71096d508 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/06mmap.txt +@@ -0,0 +1,59 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++mmap(2) -- File Memory Mapping ++---------------------------------------------------------------------- ++In aufs, the file-mapped pages are handled by a branch fs directly, no ++interaction with aufs. It means aufs_mmap() calls the branch fs's ++->mmap(). ++This approach is simple and good, but there is one problem. ++Under /proc, several entries show the mmapped files by its path (with ++device and inode number), and the printed path will be the path on the ++branch fs's instead of virtual aufs's. ++This is not a problem in most cases, but some utilities lsof(1) (and its ++user) may expect the path on aufs. ++ ++To address this issue, aufs adds a new member called vm_prfile in struct ++vm_area_struct (and struct vm_region). The original vm_file points to ++the file on the branch fs in order to handle everything correctly as ++usual. The new vm_prfile points to a virtual file in aufs, and the ++show-functions in procfs refers to vm_prfile if it is set. ++Also we need to maintain several other places where touching vm_file ++such like ++- fork()/clone() copies vma and the reference count of vm_file is ++ incremented. ++- merging vma maintains the ref count too. ++ ++This is not a good approach. It just fakes the printed path. But it ++leaves all behaviour around f_mapping unchanged. This is surely an ++advantage. ++Actually aufs had adopted another complicated approach which calls ++generic_file_mmap() and handles struct vm_operations_struct. In this ++approach, aufs met a hard problem and I could not solve it without ++switching the approach. ++ ++There may be one more another approach which is ++- bind-mount the branch-root onto the aufs-root internally ++- grab the new vfsmount (ie. struct mount) ++- lazy-umount the branch-root internally ++- in open(2) the aufs-file, open the branch-file with the hidden ++ vfsmount (instead of the original branch's vfsmount) ++- ideally this "bind-mount and lazy-umount" should be done atomically, ++ but it may be possible from userspace by the mount helper. ++ ++Adding the internal hidden vfsmount and using it in opening a file, the ++file path under /proc will be printed correctly. This approach looks ++smarter, but is not possible I am afraid. ++- aufs-root may be bind-mount later. when it happens, another hidden ++ vfsmount will be required. ++- it is hard to get the chance to bind-mount and lazy-umount ++ + in kernel-space, FS can have vfsmount in open(2) via ++ file->f_path, and aufs can know its vfsmount. But several locks are ++ already acquired, and if aufs tries to bind-mount and lazy-umount ++ here, then it may cause a deadlock. ++ + in user-space, bind-mount doesn't invoke the mount helper. ++- since /proc shows dev and ino, aufs has to give vma these info. it ++ means a new member vm_prinode will be necessary. this is essentially ++ equivalent to vm_prfile described above. ++ ++I have to give up this "looks-smater" approach. +diff --git a/Documentation/filesystems/aufs/design/06xattr.txt b/Documentation/filesystems/aufs/design/06xattr.txt +new file mode 100644 +index 000000000000..f4076a04a335 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/06xattr.txt +@@ -0,0 +1,81 @@ ++ ++# Copyright (C) 2014-2020 Junjiro R. Okajima ++ ++Listing XATTR/EA and getting the value ++---------------------------------------------------------------------- ++For the inode standard attributes (owner, group, timestamps, etc.), aufs ++shows the values from the topmost existing file. This behaviour is good ++for the non-dir entries since the bahaviour exactly matches the shown ++information. But for the directories, aufs considers all the same named ++entries on the lower branches. Which means, if one of the lower entry ++rejects readdir call, then aufs returns an error even if the topmost ++entry allows it. This behaviour is necessary to respect the branch fs's ++security, but can make users confused since the user-visible standard ++attributes don't match the behaviour. ++To address this issue, aufs has a mount option called dirperm1 which ++checks the permission for the topmost entry only, and ignores the lower ++entry's permission. ++ ++A similar issue can happen around XATTR. ++getxattr(2) and listxattr(2) families behave as if dirperm1 option is ++always set. Otherwise these very unpleasant situation would happen. ++- listxattr(2) may return the duplicated entries. ++- users may not be able to remove or reset the XATTR forever, ++ ++ ++XATTR/EA support in the internal (copy,move)-(up,down) ++---------------------------------------------------------------------- ++Generally the extended attributes of inode are categorized as these. ++- "security" for LSM and capability. ++- "system" for posix ACL, 'acl' mount option is required for the branch ++ fs generally. ++- "trusted" for userspace, CAP_SYS_ADMIN is required. ++- "user" for userspace, 'user_xattr' mount option is required for the ++ branch fs generally. ++ ++Moreover there are some other categories. Aufs handles these rather ++unpopular categories as the ordinary ones, ie. there is no special ++condition nor exception. ++ ++In copy-up, the support for XATTR on the dst branch may differ from the ++src branch. In this case, the copy-up operation will get an error and ++the original user operation which triggered the copy-up will fail. It ++can happen that even all copy-up will fail. ++When both of src and dst branches support XATTR and if an error occurs ++during copying XATTR, then the copy-up should fail obviously. That is a ++good reason and aufs should return an error to userspace. But when only ++the src branch support that XATTR, aufs should not return an error. ++For example, the src branch supports ACL but the dst branch doesn't ++because the dst branch may natively un-support it or temporary ++un-support it due to "noacl" mount option. Of course, the dst branch fs ++may NOT return an error even if the XATTR is not supported. It is ++totally up to the branch fs. ++ ++Anyway when the aufs internal copy-up gets an error from the dst branch ++fs, then aufs tries removing the just copied entry and returns the error ++to the userspace. The worst case of this situation will be all copy-up ++will fail. ++ ++For the copy-up operation, there two basic approaches. ++- copy the specified XATTR only (by category above), and return the ++ error unconditionally if it happens. ++- copy all XATTR, and ignore the error on the specified category only. ++ ++In order to support XATTR and to implement the correct behaviour, aufs ++chooses the latter approach and introduces some new branch attributes, ++"icexsec", "icexsys", "icextr", "icexusr", and "icexoth". ++They correspond to the XATTR namespaces (see above). Additionally, to be ++convenient, "icex" is also provided which means all "icex*" attributes ++are set (here the word "icex" stands for "ignore copy-error on XATTR"). ++ ++The meaning of these attributes is to ignore the error from setting ++XATTR on that branch. ++Note that aufs tries copying all XATTR unconditionally, and ignores the ++error from the dst branch according to the specified attributes. ++ ++Some XATTR may have its default value. The default value may come from ++the parent dir or the environment. If the default value is set at the ++file creating-time, it will be overwritten by copy-up. ++Some contradiction may happen I am afraid. ++Do we need another attribute to stop copying XATTR? I am unsure. For ++now, aufs implements the branch attributes to ignore the error. +diff --git a/Documentation/filesystems/aufs/design/07export.txt b/Documentation/filesystems/aufs/design/07export.txt +new file mode 100644 +index 000000000000..fcd3a3489bf8 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/07export.txt +@@ -0,0 +1,45 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++Export Aufs via NFS ++---------------------------------------------------------------------- ++Here is an approach. ++- like xino/xib, add a new file 'xigen' which stores aufs inode ++ generation. ++- iget_locked(): initialize aufs inode generation for a new inode, and ++ store it in xigen file. ++- destroy_inode(): increment aufs inode generation and store it in xigen ++ file. it is necessary even if it is not unlinked, because any data of ++ inode may be changed by UDBA. ++- encode_fh(): for a root dir, simply return FILEID_ROOT. otherwise ++ build file handle by ++ + branch id (4 bytes) ++ + superblock generation (4 bytes) ++ + inode number (4 or 8 bytes) ++ + parent dir inode number (4 or 8 bytes) ++ + inode generation (4 bytes)) ++ + return value of exportfs_encode_fh() for the parent on a branch (4 ++ bytes) ++ + file handle for a branch (by exportfs_encode_fh()) ++- fh_to_dentry(): ++ + find the index of a branch from its id in handle, and check it is ++ still exist in aufs. ++ + 1st level: get the inode number from handle and search it in cache. ++ + 2nd level: if not found in cache, get the parent inode number from ++ the handle and search it in cache. and then open the found parent ++ dir, find the matching inode number by vfs_readdir() and get its ++ name, and call lookup_one_len() for the target dentry. ++ + 3rd level: if the parent dir is not cached, call ++ exportfs_decode_fh() for a branch and get the parent on a branch, ++ build a pathname of it, convert it a pathname in aufs, call ++ path_lookup(). now aufs gets a parent dir dentry, then handle it as ++ the 2nd level. ++ + to open the dir, aufs needs struct vfsmount. aufs keeps vfsmount ++ for every branch, but not itself. to get this, (currently) aufs ++ searches in current->nsproxy->mnt_ns list. it may not be a good ++ idea, but I didn't get other approach. ++ + test the generation of the gotten inode. ++- every inode operation: they may get EBUSY due to UDBA. in this case, ++ convert it into ESTALE for NFSD. ++- readdir(): call lockdep_on/off() because filldir in NFSD calls ++ lookup_one_len(), vfs_getattr(), encode_fh() and others. +diff --git a/Documentation/filesystems/aufs/design/08shwh.txt b/Documentation/filesystems/aufs/design/08shwh.txt +new file mode 100644 +index 000000000000..f252e17154b1 +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/08shwh.txt +@@ -0,0 +1,39 @@ ++ ++# Copyright (C) 2005-2020 Junjiro R. Okajima ++ ++Show Whiteout Mode (shwh) ++---------------------------------------------------------------------- ++Generally aufs hides the name of whiteouts. But in some cases, to show ++them is very useful for users. For instance, creating a new middle layer ++(branch) by merging existing layers. ++ ++(borrowing aufs1 HOW-TO from a user, Michael Towers) ++When you have three branches, ++- Bottom: 'system', squashfs (underlying base system), read-only ++- Middle: 'mods', squashfs, read-only ++- Top: 'overlay', ram (tmpfs), read-write ++ ++The top layer is loaded at boot time and saved at shutdown, to preserve ++the changes made to the system during the session. ++When larger changes have been made, or smaller changes have accumulated, ++the size of the saved top layer data grows. At this point, it would be ++nice to be able to merge the two overlay branches ('mods' and 'overlay') ++and rewrite the 'mods' squashfs, clearing the top layer and thus ++restoring save and load speed. ++ ++This merging is simplified by the use of another aufs mount, of just the ++two overlay branches using the 'shwh' option. ++# mount -t aufs -o ro,shwh,br:/livesys/overlay=ro+wh:/livesys/mods=rr+wh \ ++ aufs /livesys/merge_union ++ ++A merged view of these two branches is then available at ++/livesys/merge_union, and the new feature is that the whiteouts are ++visible! ++Note that in 'shwh' mode the aufs mount must be 'ro', which will disable ++writing to all branches. Also the default mode for all branches is 'ro'. ++It is now possible to save the combined contents of the two overlay ++branches to a new squashfs, e.g.: ++# mksquashfs /livesys/merge_union /path/to/newmods.squash ++ ++This new squashfs archive can be stored on the boot device and the ++initramfs will use it to replace the old one at the next boot. +diff --git a/Documentation/filesystems/aufs/design/10dynop.txt b/Documentation/filesystems/aufs/design/10dynop.txt +new file mode 100644 +index 000000000000..2b90eecb267d +--- /dev/null ++++ b/Documentation/filesystems/aufs/design/10dynop.txt +@@ -0,0 +1,34 @@ ++ ++# Copyright (C) 2010-2020 Junjiro R. Okajima ++ ++Dynamically customizable FS operations ++---------------------------------------------------------------------- ++Generally FS operations (struct inode_operations, struct ++address_space_operations, struct file_operations, etc.) are defined as ++"static const", but it never means that FS have only one set of ++operation. Some FS have multiple sets of them. For instance, ext2 has ++three sets, one for XIP, for NOBH, and for normal. ++Since aufs overrides and redirects these operations, sometimes aufs has ++to change its behaviour according to the branch FS type. More importantly ++VFS acts differently if a function (member in the struct) is set or ++not. It means aufs should have several sets of operations and select one ++among them according to the branch FS definition. ++ ++In order to solve this problem and not to affect the behaviour of VFS, ++aufs defines these operations dynamically. For instance, aufs defines ++dummy direct_IO function for struct address_space_operations, but it may ++not be set to the address_space_operations actually. When the branch FS ++doesn't have it, aufs doesn't set it to its address_space_operations ++while the function definition itself is still alive. So the behaviour ++itself will not change, and it will return an error when direct_IO is ++not set. ++ ++The lifetime of these dynamically generated operation object is ++maintained by aufs branch object. When the branch is removed from aufs, ++the reference counter of the object is decremented. When it reaches ++zero, the dynamically generated operation object will be freed. ++ ++This approach is designed to support AIO (io_submit), Direct I/O and ++XIP (DAX) mainly. ++Currently this approach is applied to address_space_operations for ++regular files only. +diff --git a/MAINTAINERS b/MAINTAINERS +index 4e2698cc7e23..491f32f3b072 100644 +--- a/MAINTAINERS ++++ b/MAINTAINERS +@@ -2984,6 +2984,19 @@ F: include/linux/audit.h + F: include/uapi/linux/audit.h + F: kernel/audit* + ++AUFS (advanced multi layered unification filesystem) FILESYSTEM ++M: "J. R. Okajima" ++L: aufs-users@lists.sourceforge.net (members only) ++L: linux-unionfs@vger.kernel.org ++W: http://aufs.sourceforge.net ++T: git://github.com/sfjro/aufs4-linux.git ++S: Supported ++F: Documentation/filesystems/aufs/ ++F: Documentation/ABI/testing/debugfs-aufs ++F: Documentation/ABI/testing/sysfs-aufs ++F: fs/aufs/ ++F: include/uapi/linux/aufs_type.h ++ + AUXILIARY DISPLAY DRIVERS + M: Miguel Ojeda Sandonis + S: Maintained +diff --git a/drivers/block/loop.c b/drivers/block/loop.c +index 475e1a738560..8d77e68aa52b 100644 +--- a/drivers/block/loop.c ++++ b/drivers/block/loop.c +@@ -763,6 +763,24 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev, + return error; + } + ++/* ++ * for AUFS ++ * no get/put for file. ++ */ ++struct file *loop_backing_file(struct super_block *sb) ++{ ++ struct file *ret; ++ struct loop_device *l; ++ ++ ret = NULL; ++ if (MAJOR(sb->s_dev) == LOOP_MAJOR) { ++ l = sb->s_bdev->bd_disk->private_data; ++ ret = l->lo_backing_file; ++ } ++ return ret; ++} ++EXPORT_SYMBOL_GPL(loop_backing_file); ++ + /* loop sysfs attributes */ + + static ssize_t loop_attr_show(struct device *dev, char *page, +diff --git a/fs/Kconfig b/fs/Kconfig +index a88aa3af73c1..0f0caa023fb9 100644 +--- a/fs/Kconfig ++++ b/fs/Kconfig +@@ -267,6 +267,7 @@ source "fs/sysv/Kconfig" + source "fs/ufs/Kconfig" + source "fs/erofs/Kconfig" + source "fs/vboxsf/Kconfig" ++source "fs/aufs/Kconfig" + + endif # MISC_FILESYSTEMS + +diff --git a/fs/Makefile b/fs/Makefile +index 2ce5112b02c8..d9b4a5198553 100644 +--- a/fs/Makefile ++++ b/fs/Makefile +@@ -136,3 +136,4 @@ obj-$(CONFIG_EFIVAR_FS) += efivarfs/ + obj-$(CONFIG_EROFS_FS) += erofs/ + obj-$(CONFIG_VBOXSF_FS) += vboxsf/ + obj-$(CONFIG_ZONEFS_FS) += zonefs/ ++obj-$(CONFIG_AUFS_FS) += aufs/ +diff --git a/fs/aufs/Kconfig b/fs/aufs/Kconfig +new file mode 100644 +index 000000000000..d9ef85bc962e +--- /dev/null ++++ b/fs/aufs/Kconfig +@@ -0,0 +1,199 @@ ++# SPDX-License-Identifier: GPL-2.0 ++config AUFS_FS ++ tristate "Aufs (Advanced multi layered unification filesystem) support" ++ help ++ Aufs is a stackable unification filesystem such as Unionfs, ++ which unifies several directories and provides a merged single ++ directory. ++ In the early days, aufs was entirely re-designed and ++ re-implemented Unionfs Version 1.x series. Introducing many ++ original ideas, approaches and improvements, it becomes totally ++ different from Unionfs while keeping the basic features. ++ ++if AUFS_FS ++choice ++ prompt "Maximum number of branches" ++ default AUFS_BRANCH_MAX_127 ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_127 ++ bool "127" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_511 ++ bool "511" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_1023 ++ bool "1023" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_32767 ++ bool "32767" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++endchoice ++ ++config AUFS_SBILIST ++ bool ++ depends on AUFS_MAGIC_SYSRQ || PROC_FS ++ default y ++ help ++ Automatic configuration for internal use. ++ When aufs supports Magic SysRq or /proc, enabled automatically. ++ ++config AUFS_HNOTIFY ++ bool "Detect direct branch access (bypassing aufs)" ++ help ++ If you want to modify files on branches directly, eg. bypassing aufs, ++ and want aufs to detect the changes of them fully, then enable this ++ option and use 'udba=notify' mount option. ++ Currently there is only one available configuration, "fsnotify". ++ It will have a negative impact to the performance. ++ See detail in aufs.5. ++ ++choice ++ prompt "method" if AUFS_HNOTIFY ++ default AUFS_HFSNOTIFY ++config AUFS_HFSNOTIFY ++ bool "fsnotify" ++ select FSNOTIFY ++endchoice ++ ++config AUFS_EXPORT ++ bool "NFS-exportable aufs" ++ depends on EXPORTFS = y ++ help ++ If you want to export your mounted aufs via NFS, then enable this ++ option. There are several requirements for this configuration. ++ See detail in aufs.5. ++ ++config AUFS_INO_T_64 ++ bool ++ depends on AUFS_EXPORT ++ depends on 64BIT && !(ALPHA || S390) ++ default y ++ help ++ Automatic configuration for internal use. ++ /* typedef unsigned long/int __kernel_ino_t */ ++ /* alpha and s390x are int */ ++ ++config AUFS_XATTR ++ bool "support for XATTR/EA (including Security Labels)" ++ help ++ If your branch fs supports XATTR/EA and you want to make them ++ available in aufs too, then enable this opsion and specify the ++ branch attributes for EA. ++ See detail in aufs.5. ++ ++config AUFS_FHSM ++ bool "File-based Hierarchical Storage Management" ++ help ++ Hierarchical Storage Management (or HSM) is a well-known feature ++ in the storage world. Aufs provides this feature as file-based. ++ with multiple branches. ++ These multiple branches are prioritized, ie. the topmost one ++ should be the fastest drive and be used heavily. ++ ++config AUFS_RDU ++ bool "Readdir in userspace" ++ help ++ Aufs has two methods to provide a merged view for a directory, ++ by a user-space library and by kernel-space natively. The latter ++ is always enabled but sometimes large and slow. ++ If you enable this option, install the library in aufs2-util ++ package, and set some environment variables for your readdir(3), ++ then the work will be handled in user-space which generally ++ shows better performance in most cases. ++ See detail in aufs.5. ++ ++config AUFS_DIRREN ++ bool "Workaround for rename(2)-ing a directory" ++ help ++ By default, aufs returns EXDEV error in renameing a dir who has ++ his child on the lower branch, since it is a bad idea to issue ++ rename(2) internally for every lower branch. But user may not ++ accept this behaviour. So here is a workaround to allow such ++ rename(2) and store some extra infromation on the writable ++ branch. Obviously this costs high (and I don't like it). ++ To use this feature, you need to enable this configuration AND ++ to specify the mount option `dirren.' ++ See details in aufs.5 and the design documents. ++ ++config AUFS_SHWH ++ bool "Show whiteouts" ++ help ++ If you want to make the whiteouts in aufs visible, then enable ++ this option and specify 'shwh' mount option. Although it may ++ sounds like philosophy or something, but in technically it ++ simply shows the name of whiteout with keeping its behaviour. ++ ++config AUFS_BR_RAMFS ++ bool "Ramfs (initramfs/rootfs) as an aufs branch" ++ help ++ If you want to use ramfs as an aufs branch fs, then enable this ++ option. Generally tmpfs is recommended. ++ Aufs prohibited them to be a branch fs by default, because ++ initramfs becomes unusable after switch_root or something ++ generally. If you sets initramfs as an aufs branch and boot your ++ system by switch_root, you will meet a problem easily since the ++ files in initramfs may be inaccessible. ++ Unless you are going to use ramfs as an aufs branch fs without ++ switch_root or something, leave it N. ++ ++config AUFS_BR_FUSE ++ bool "Fuse fs as an aufs branch" ++ depends on FUSE_FS ++ select AUFS_POLL ++ help ++ If you want to use fuse-based userspace filesystem as an aufs ++ branch fs, then enable this option. ++ It implements the internal poll(2) operation which is ++ implemented by fuse only (curretnly). ++ ++config AUFS_POLL ++ bool ++ help ++ Automatic configuration for internal use. ++ ++config AUFS_BR_HFSPLUS ++ bool "Hfsplus as an aufs branch" ++ depends on HFSPLUS_FS ++ default y ++ help ++ If you want to use hfsplus fs as an aufs branch fs, then enable ++ this option. This option introduces a small overhead at ++ copying-up a file on hfsplus. ++ ++config AUFS_BDEV_LOOP ++ bool ++ depends on BLK_DEV_LOOP ++ default y ++ help ++ Automatic configuration for internal use. ++ Convert =[ym] into =y. ++ ++config AUFS_DEBUG ++ bool "Debug aufs" ++ help ++ Enable this to compile aufs internal debug code. ++ It will have a negative impact to the performance. ++ ++config AUFS_MAGIC_SYSRQ ++ bool ++ depends on AUFS_DEBUG && MAGIC_SYSRQ ++ default y ++ help ++ Automatic configuration for internal use. ++ When aufs supports Magic SysRq, enabled automatically. ++endif +diff --git a/fs/aufs/Makefile b/fs/aufs/Makefile +new file mode 100644 +index 000000000000..9de70de0f337 +--- /dev/null ++++ b/fs/aufs/Makefile +@@ -0,0 +1,39 @@ ++# SPDX-License-Identifier: GPL-2.0 ++ ++include ${srctree}/${src}/magic.mk ++-include ${srctree}/${src}/priv_def.mk ++ ++# cf. include/linux/kernel.h ++# enable pr_debug ++ccflags-y += -DDEBUG ++# sparse requires the full pathname ++ccflags-y += -include ${srctree}/include/uapi/linux/aufs_type.h ++ ++obj-$(CONFIG_AUFS_FS) += aufs.o ++aufs-y := module.o sbinfo.o super.o branch.o xino.o sysaufs.o opts.o \ ++ wkq.o vfsub.o dcsub.o \ ++ cpup.o whout.o wbr_policy.o \ ++ dinfo.o dentry.o \ ++ dynop.o \ ++ finfo.o file.o f_op.o \ ++ dir.o vdir.o \ ++ iinfo.o inode.o i_op.o i_op_add.o i_op_del.o i_op_ren.o \ ++ mvdown.o ioctl.o ++ ++# all are boolean ++aufs-$(CONFIG_PROC_FS) += procfs.o plink.o ++aufs-$(CONFIG_SYSFS) += sysfs.o ++aufs-$(CONFIG_DEBUG_FS) += dbgaufs.o ++aufs-$(CONFIG_AUFS_BDEV_LOOP) += loop.o ++aufs-$(CONFIG_AUFS_HNOTIFY) += hnotify.o ++aufs-$(CONFIG_AUFS_HFSNOTIFY) += hfsnotify.o ++aufs-$(CONFIG_AUFS_EXPORT) += export.o ++aufs-$(CONFIG_AUFS_XATTR) += xattr.o ++aufs-$(CONFIG_FS_POSIX_ACL) += posix_acl.o ++aufs-$(CONFIG_AUFS_DIRREN) += dirren.o ++aufs-$(CONFIG_AUFS_FHSM) += fhsm.o ++aufs-$(CONFIG_AUFS_POLL) += poll.o ++aufs-$(CONFIG_AUFS_RDU) += rdu.o ++aufs-$(CONFIG_AUFS_BR_HFSPLUS) += hfsplus.o ++aufs-$(CONFIG_AUFS_DEBUG) += debug.o ++aufs-$(CONFIG_AUFS_MAGIC_SYSRQ) += sysrq.o +diff --git a/fs/aufs/aufs.h b/fs/aufs/aufs.h +new file mode 100644 +index 000000000000..c50f959844e8 +--- /dev/null ++++ b/fs/aufs/aufs.h +@@ -0,0 +1,49 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * all header files ++ */ ++ ++#ifndef __AUFS_H__ ++#define __AUFS_H__ ++ ++#ifdef __KERNEL__ ++ ++#define AuStub(type, name, body, ...) \ ++ static inline type name(__VA_ARGS__) { body; } ++ ++#define AuStubVoid(name, ...) \ ++ AuStub(void, name, , __VA_ARGS__) ++#define AuStubInt0(name, ...) \ ++ AuStub(int, name, return 0, __VA_ARGS__) ++ ++#include "debug.h" ++ ++#include "branch.h" ++#include "cpup.h" ++#include "dcsub.h" ++#include "dbgaufs.h" ++#include "dentry.h" ++#include "dir.h" ++#include "dirren.h" ++#include "dynop.h" ++#include "file.h" ++#include "fstype.h" ++#include "hbl.h" ++#include "inode.h" ++#include "lcnt.h" ++#include "loop.h" ++#include "module.h" ++#include "opts.h" ++#include "rwsem.h" ++#include "super.h" ++#include "sysaufs.h" ++#include "vfsub.h" ++#include "whout.h" ++#include "wkq.h" ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_H__ */ +diff --git a/fs/aufs/branch.c b/fs/aufs/branch.c +new file mode 100644 +index 000000000000..3319245c0361 +--- /dev/null ++++ b/fs/aufs/branch.c +@@ -0,0 +1,1414 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * branch management ++ */ ++ ++#include ++#include ++#include "aufs.h" ++ ++/* ++ * free a single branch ++ */ ++static void au_br_do_free(struct au_branch *br) ++{ ++ int i; ++ struct au_wbr *wbr; ++ struct au_dykey **key; ++ ++ au_hnotify_fin_br(br); ++ /* always, regardless the mount option */ ++ au_dr_hino_free(&br->br_dirren); ++ au_xino_put(br); ++ ++ AuLCntZero(au_lcnt_read(&br->br_nfiles, /*do_rev*/0)); ++ au_lcnt_fin(&br->br_nfiles, /*do_sync*/0); ++ AuLCntZero(au_lcnt_read(&br->br_count, /*do_rev*/0)); ++ au_lcnt_fin(&br->br_count, /*do_sync*/0); ++ ++ wbr = br->br_wbr; ++ if (wbr) { ++ for (i = 0; i < AuBrWh_Last; i++) ++ dput(wbr->wbr_wh[i]); ++ AuDebugOn(atomic_read(&wbr->wbr_wh_running)); ++ AuRwDestroy(&wbr->wbr_wh_rwsem); ++ } ++ ++ if (br->br_fhsm) { ++ au_br_fhsm_fin(br->br_fhsm); ++ au_kfree_try_rcu(br->br_fhsm); ++ } ++ ++ key = br->br_dykey; ++ for (i = 0; i < AuBrDynOp; i++, key++) ++ if (*key) ++ au_dy_put(*key); ++ else ++ break; ++ ++ /* recursive lock, s_umount of branch's */ ++ /* synchronize_rcu(); */ /* why? */ ++ lockdep_off(); ++ path_put(&br->br_path); ++ lockdep_on(); ++ au_kfree_rcu(wbr); ++ au_lcnt_wait_for_fin(&br->br_nfiles); ++ au_lcnt_wait_for_fin(&br->br_count); ++ /* I don't know why, but percpu_refcount requires this */ ++ /* synchronize_rcu(); */ ++ au_kfree_rcu(br); ++} ++ ++/* ++ * frees all branches ++ */ ++void au_br_free(struct au_sbinfo *sbinfo) ++{ ++ aufs_bindex_t bmax; ++ struct au_branch **br; ++ ++ AuRwMustWriteLock(&sbinfo->si_rwsem); ++ ++ bmax = sbinfo->si_bbot + 1; ++ br = sbinfo->si_branch; ++ while (bmax--) ++ au_br_do_free(*br++); ++} ++ ++/* ++ * find the index of a branch which is specified by @br_id. ++ */ ++int au_br_index(struct super_block *sb, aufs_bindex_t br_id) ++{ ++ aufs_bindex_t bindex, bbot; ++ ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) ++ if (au_sbr_id(sb, bindex) == br_id) ++ return bindex; ++ return -1; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * add a branch ++ */ ++ ++static int test_overlap(struct super_block *sb, struct dentry *h_adding, ++ struct dentry *h_root) ++{ ++ if (unlikely(h_adding == h_root ++ || au_test_loopback_overlap(sb, h_adding))) ++ return 1; ++ if (h_adding->d_sb != h_root->d_sb) ++ return 0; ++ return au_test_subdir(h_adding, h_root) ++ || au_test_subdir(h_root, h_adding); ++} ++ ++/* ++ * returns a newly allocated branch. @new_nbranch is a number of branches ++ * after adding a branch. ++ */ ++static struct au_branch *au_br_alloc(struct super_block *sb, int new_nbranch, ++ int perm) ++{ ++ struct au_branch *add_branch; ++ struct dentry *root; ++ struct inode *inode; ++ int err; ++ ++ err = -ENOMEM; ++ add_branch = kzalloc(sizeof(*add_branch), GFP_NOFS); ++ if (unlikely(!add_branch)) ++ goto out; ++ add_branch->br_xino = au_xino_alloc(/*nfile*/1); ++ if (unlikely(!add_branch->br_xino)) ++ goto out_br; ++ err = au_hnotify_init_br(add_branch, perm); ++ if (unlikely(err)) ++ goto out_xino; ++ ++ if (au_br_writable(perm)) { ++ /* may be freed separately at changing the branch permission */ ++ add_branch->br_wbr = kzalloc(sizeof(*add_branch->br_wbr), ++ GFP_NOFS); ++ if (unlikely(!add_branch->br_wbr)) ++ goto out_hnotify; ++ } ++ ++ if (au_br_fhsm(perm)) { ++ err = au_fhsm_br_alloc(add_branch); ++ if (unlikely(err)) ++ goto out_wbr; ++ } ++ ++ root = sb->s_root; ++ err = au_sbr_realloc(au_sbi(sb), new_nbranch, /*may_shrink*/0); ++ if (!err) ++ err = au_di_realloc(au_di(root), new_nbranch, /*may_shrink*/0); ++ if (!err) { ++ inode = d_inode(root); ++ err = au_hinode_realloc(au_ii(inode), new_nbranch, ++ /*may_shrink*/0); ++ } ++ if (!err) ++ return add_branch; /* success */ ++ ++out_wbr: ++ au_kfree_rcu(add_branch->br_wbr); ++out_hnotify: ++ au_hnotify_fin_br(add_branch); ++out_xino: ++ au_xino_put(add_branch); ++out_br: ++ au_kfree_rcu(add_branch); ++out: ++ return ERR_PTR(err); ++} ++ ++/* ++ * test if the branch permission is legal or not. ++ */ ++static int test_br(struct inode *inode, int brperm, char *path) ++{ ++ int err; ++ ++ err = (au_br_writable(brperm) && IS_RDONLY(inode)); ++ if (!err) ++ goto out; ++ ++ err = -EINVAL; ++ pr_err("write permission for readonly mount or inode, %s\n", path); ++ ++out: ++ return err; ++} ++ ++/* ++ * returns: ++ * 0: success, the caller will add it ++ * plus: success, it is already unified, the caller should ignore it ++ * minus: error ++ */ ++static int test_add(struct super_block *sb, struct au_opt_add *add, int remount) ++{ ++ int err; ++ aufs_bindex_t bbot, bindex; ++ struct dentry *root, *h_dentry; ++ struct inode *inode, *h_inode; ++ ++ root = sb->s_root; ++ bbot = au_sbbot(sb); ++ if (unlikely(bbot >= 0 ++ && au_find_dbindex(root, add->path.dentry) >= 0)) { ++ err = 1; ++ if (!remount) { ++ err = -EINVAL; ++ pr_err("%s duplicated\n", add->pathname); ++ } ++ goto out; ++ } ++ ++ err = -ENOSPC; /* -E2BIG; */ ++ if (unlikely(AUFS_BRANCH_MAX <= add->bindex ++ || AUFS_BRANCH_MAX - 1 <= bbot)) { ++ pr_err("number of branches exceeded %s\n", add->pathname); ++ goto out; ++ } ++ ++ err = -EDOM; ++ if (unlikely(add->bindex < 0 || bbot + 1 < add->bindex)) { ++ pr_err("bad index %d\n", add->bindex); ++ goto out; ++ } ++ ++ inode = d_inode(add->path.dentry); ++ err = -ENOENT; ++ if (unlikely(!inode->i_nlink)) { ++ pr_err("no existence %s\n", add->pathname); ++ goto out; ++ } ++ ++ err = -EINVAL; ++ if (unlikely(inode->i_sb == sb)) { ++ pr_err("%s must be outside\n", add->pathname); ++ goto out; ++ } ++ ++ if (unlikely(au_test_fs_unsuppoted(inode->i_sb))) { ++ pr_err("unsupported filesystem, %s (%s)\n", ++ add->pathname, au_sbtype(inode->i_sb)); ++ goto out; ++ } ++ ++ if (unlikely(inode->i_sb->s_stack_depth)) { ++ pr_err("already stacked, %s (%s)\n", ++ add->pathname, au_sbtype(inode->i_sb)); ++ goto out; ++ } ++ ++ err = test_br(d_inode(add->path.dentry), add->perm, add->pathname); ++ if (unlikely(err)) ++ goto out; ++ ++ if (bbot < 0) ++ return 0; /* success */ ++ ++ err = -EINVAL; ++ for (bindex = 0; bindex <= bbot; bindex++) ++ if (unlikely(test_overlap(sb, add->path.dentry, ++ au_h_dptr(root, bindex)))) { ++ pr_err("%s is overlapped\n", add->pathname); ++ goto out; ++ } ++ ++ err = 0; ++ if (au_opt_test(au_mntflags(sb), WARN_PERM)) { ++ h_dentry = au_h_dptr(root, 0); ++ h_inode = d_inode(h_dentry); ++ if ((h_inode->i_mode & S_IALLUGO) != (inode->i_mode & S_IALLUGO) ++ || !uid_eq(h_inode->i_uid, inode->i_uid) ++ || !gid_eq(h_inode->i_gid, inode->i_gid)) ++ pr_warn("uid/gid/perm %s %u/%u/0%o, %u/%u/0%o\n", ++ add->pathname, ++ i_uid_read(inode), i_gid_read(inode), ++ (inode->i_mode & S_IALLUGO), ++ i_uid_read(h_inode), i_gid_read(h_inode), ++ (h_inode->i_mode & S_IALLUGO)); ++ } ++ ++out: ++ return err; ++} ++ ++/* ++ * initialize or clean the whiteouts for an adding branch ++ */ ++static int au_br_init_wh(struct super_block *sb, struct au_branch *br, ++ int new_perm) ++{ ++ int err, old_perm; ++ aufs_bindex_t bindex; ++ struct inode *h_inode; ++ struct au_wbr *wbr; ++ struct au_hinode *hdir; ++ struct dentry *h_dentry; ++ ++ err = vfsub_mnt_want_write(au_br_mnt(br)); ++ if (unlikely(err)) ++ goto out; ++ ++ wbr = br->br_wbr; ++ old_perm = br->br_perm; ++ br->br_perm = new_perm; ++ hdir = NULL; ++ h_inode = NULL; ++ bindex = au_br_index(sb, br->br_id); ++ if (0 <= bindex) { ++ hdir = au_hi(d_inode(sb->s_root), bindex); ++ au_hn_inode_lock_nested(hdir, AuLsc_I_PARENT); ++ } else { ++ h_dentry = au_br_dentry(br); ++ h_inode = d_inode(h_dentry); ++ inode_lock_nested(h_inode, AuLsc_I_PARENT); ++ } ++ if (!wbr) ++ err = au_wh_init(br, sb); ++ else { ++ wbr_wh_write_lock(wbr); ++ err = au_wh_init(br, sb); ++ wbr_wh_write_unlock(wbr); ++ } ++ if (hdir) ++ au_hn_inode_unlock(hdir); ++ else ++ inode_unlock(h_inode); ++ vfsub_mnt_drop_write(au_br_mnt(br)); ++ br->br_perm = old_perm; ++ ++ if (!err && wbr && !au_br_writable(new_perm)) { ++ au_kfree_rcu(wbr); ++ br->br_wbr = NULL; ++ } ++ ++out: ++ return err; ++} ++ ++static int au_wbr_init(struct au_branch *br, struct super_block *sb, ++ int perm) ++{ ++ int err; ++ struct kstatfs kst; ++ struct au_wbr *wbr; ++ ++ wbr = br->br_wbr; ++ au_rw_init(&wbr->wbr_wh_rwsem); ++ atomic_set(&wbr->wbr_wh_running, 0); ++ ++ /* ++ * a limit for rmdir/rename a dir ++ * cf. AUFS_MAX_NAMELEN in include/uapi/linux/aufs_type.h ++ */ ++ err = vfs_statfs(&br->br_path, &kst); ++ if (unlikely(err)) ++ goto out; ++ err = -EINVAL; ++ if (kst.f_namelen >= NAME_MAX) ++ err = au_br_init_wh(sb, br, perm); ++ else ++ pr_err("%pd(%s), unsupported namelen %ld\n", ++ au_br_dentry(br), ++ au_sbtype(au_br_dentry(br)->d_sb), kst.f_namelen); ++ ++out: ++ return err; ++} ++ ++/* initialize a new branch */ ++static int au_br_init(struct au_branch *br, struct super_block *sb, ++ struct au_opt_add *add) ++{ ++ int err; ++ struct au_branch *brbase; ++ struct file *xf; ++ struct inode *h_inode; ++ ++ err = 0; ++ br->br_perm = add->perm; ++ br->br_path = add->path; /* set first, path_get() later */ ++ spin_lock_init(&br->br_dykey_lock); ++ au_lcnt_init(&br->br_nfiles, /*release*/NULL); ++ au_lcnt_init(&br->br_count, /*release*/NULL); ++ br->br_id = au_new_br_id(sb); ++ AuDebugOn(br->br_id < 0); ++ ++ /* always, regardless the given option */ ++ err = au_dr_br_init(sb, br, &add->path); ++ if (unlikely(err)) ++ goto out_err; ++ ++ if (au_br_writable(add->perm)) { ++ err = au_wbr_init(br, sb, add->perm); ++ if (unlikely(err)) ++ goto out_err; ++ } ++ ++ if (au_opt_test(au_mntflags(sb), XINO)) { ++ brbase = au_sbr(sb, 0); ++ xf = au_xino_file(brbase->br_xino, /*idx*/-1); ++ AuDebugOn(!xf); ++ h_inode = d_inode(add->path.dentry); ++ err = au_xino_init_br(sb, br, h_inode->i_ino, &xf->f_path); ++ if (unlikely(err)) { ++ AuDebugOn(au_xino_file(br->br_xino, /*idx*/-1)); ++ goto out_err; ++ } ++ } ++ ++ sysaufs_br_init(br); ++ path_get(&br->br_path); ++ goto out; /* success */ ++ ++out_err: ++ memset(&br->br_path, 0, sizeof(br->br_path)); ++out: ++ return err; ++} ++ ++static void au_br_do_add_brp(struct au_sbinfo *sbinfo, aufs_bindex_t bindex, ++ struct au_branch *br, aufs_bindex_t bbot, ++ aufs_bindex_t amount) ++{ ++ struct au_branch **brp; ++ ++ AuRwMustWriteLock(&sbinfo->si_rwsem); ++ ++ brp = sbinfo->si_branch + bindex; ++ memmove(brp + 1, brp, sizeof(*brp) * amount); ++ *brp = br; ++ sbinfo->si_bbot++; ++ if (unlikely(bbot < 0)) ++ sbinfo->si_bbot = 0; ++} ++ ++static void au_br_do_add_hdp(struct au_dinfo *dinfo, aufs_bindex_t bindex, ++ aufs_bindex_t bbot, aufs_bindex_t amount) ++{ ++ struct au_hdentry *hdp; ++ ++ AuRwMustWriteLock(&dinfo->di_rwsem); ++ ++ hdp = au_hdentry(dinfo, bindex); ++ memmove(hdp + 1, hdp, sizeof(*hdp) * amount); ++ au_h_dentry_init(hdp); ++ dinfo->di_bbot++; ++ if (unlikely(bbot < 0)) ++ dinfo->di_btop = 0; ++} ++ ++static void au_br_do_add_hip(struct au_iinfo *iinfo, aufs_bindex_t bindex, ++ aufs_bindex_t bbot, aufs_bindex_t amount) ++{ ++ struct au_hinode *hip; ++ ++ AuRwMustWriteLock(&iinfo->ii_rwsem); ++ ++ hip = au_hinode(iinfo, bindex); ++ memmove(hip + 1, hip, sizeof(*hip) * amount); ++ au_hinode_init(hip); ++ iinfo->ii_bbot++; ++ if (unlikely(bbot < 0)) ++ iinfo->ii_btop = 0; ++} ++ ++static void au_br_do_add(struct super_block *sb, struct au_branch *br, ++ aufs_bindex_t bindex) ++{ ++ struct dentry *root, *h_dentry; ++ struct inode *root_inode, *h_inode; ++ aufs_bindex_t bbot, amount; ++ ++ root = sb->s_root; ++ root_inode = d_inode(root); ++ bbot = au_sbbot(sb); ++ amount = bbot + 1 - bindex; ++ h_dentry = au_br_dentry(br); ++ au_sbilist_lock(); ++ au_br_do_add_brp(au_sbi(sb), bindex, br, bbot, amount); ++ au_br_do_add_hdp(au_di(root), bindex, bbot, amount); ++ au_br_do_add_hip(au_ii(root_inode), bindex, bbot, amount); ++ au_set_h_dptr(root, bindex, dget(h_dentry)); ++ h_inode = d_inode(h_dentry); ++ au_set_h_iptr(root_inode, bindex, au_igrab(h_inode), /*flags*/0); ++ au_sbilist_unlock(); ++} ++ ++int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount) ++{ ++ int err; ++ aufs_bindex_t bbot, add_bindex; ++ struct dentry *root, *h_dentry; ++ struct inode *root_inode; ++ struct au_branch *add_branch; ++ ++ root = sb->s_root; ++ root_inode = d_inode(root); ++ IMustLock(root_inode); ++ IiMustWriteLock(root_inode); ++ err = test_add(sb, add, remount); ++ if (unlikely(err < 0)) ++ goto out; ++ if (err) { ++ err = 0; ++ goto out; /* success */ ++ } ++ ++ bbot = au_sbbot(sb); ++ add_branch = au_br_alloc(sb, bbot + 2, add->perm); ++ err = PTR_ERR(add_branch); ++ if (IS_ERR(add_branch)) ++ goto out; ++ ++ err = au_br_init(add_branch, sb, add); ++ if (unlikely(err)) { ++ au_br_do_free(add_branch); ++ goto out; ++ } ++ ++ add_bindex = add->bindex; ++ sysaufs_brs_del(sb, add_bindex); /* remove successors */ ++ au_br_do_add(sb, add_branch, add_bindex); ++ sysaufs_brs_add(sb, add_bindex); /* append successors */ ++ dbgaufs_brs_add(sb, add_bindex, /*topdown*/0); /* rename successors */ ++ ++ h_dentry = add->path.dentry; ++ if (!add_bindex) { ++ au_cpup_attr_all(root_inode, /*force*/1); ++ sb->s_maxbytes = h_dentry->d_sb->s_maxbytes; ++ } else ++ au_add_nlink(root_inode, d_inode(h_dentry)); ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static unsigned long long au_farray_cb(struct super_block *sb, void *a, ++ unsigned long long max __maybe_unused, ++ void *arg) ++{ ++ unsigned long long n; ++ struct file **p, *f; ++ struct hlist_bl_head *files; ++ struct hlist_bl_node *pos; ++ struct au_finfo *finfo; ++ ++ n = 0; ++ p = a; ++ files = &au_sbi(sb)->si_files; ++ hlist_bl_lock(files); ++ hlist_bl_for_each_entry(finfo, pos, files, fi_hlist) { ++ f = finfo->fi_file; ++ if (file_count(f) ++ && !special_file(file_inode(f)->i_mode)) { ++ get_file(f); ++ *p++ = f; ++ n++; ++ AuDebugOn(n > max); ++ } ++ } ++ hlist_bl_unlock(files); ++ ++ return n; ++} ++ ++static struct file **au_farray_alloc(struct super_block *sb, ++ unsigned long long *max) ++{ ++ struct au_sbinfo *sbi; ++ ++ sbi = au_sbi(sb); ++ *max = au_lcnt_read(&sbi->si_nfiles, /*do_rev*/1); ++ return au_array_alloc(max, au_farray_cb, sb, /*arg*/NULL); ++} ++ ++static void au_farray_free(struct file **a, unsigned long long max) ++{ ++ unsigned long long ull; ++ ++ for (ull = 0; ull < max; ull++) ++ if (a[ull]) ++ fput(a[ull]); ++ kvfree(a); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * delete a branch ++ */ ++ ++/* to show the line number, do not make it inlined function */ ++#define AuVerbose(do_info, fmt, ...) do { \ ++ if (do_info) \ ++ pr_info(fmt, ##__VA_ARGS__); \ ++} while (0) ++ ++static int au_test_ibusy(struct inode *inode, aufs_bindex_t btop, ++ aufs_bindex_t bbot) ++{ ++ return (inode && !S_ISDIR(inode->i_mode)) || btop == bbot; ++} ++ ++static int au_test_dbusy(struct dentry *dentry, aufs_bindex_t btop, ++ aufs_bindex_t bbot) ++{ ++ return au_test_ibusy(d_inode(dentry), btop, bbot); ++} ++ ++/* ++ * test if the branch is deletable or not. ++ */ ++static int test_dentry_busy(struct dentry *root, aufs_bindex_t bindex, ++ unsigned int sigen, const unsigned int verbose) ++{ ++ int err, i, j, ndentry; ++ aufs_bindex_t btop, bbot; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry *d; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_dcsub_pages(&dpages, root, NULL, NULL); ++ if (unlikely(err)) ++ goto out_dpages; ++ ++ for (i = 0; !err && i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ ndentry = dpage->ndentry; ++ for (j = 0; !err && j < ndentry; j++) { ++ d = dpage->dentries[j]; ++ AuDebugOn(au_dcount(d) <= 0); ++ if (!au_digen_test(d, sigen)) { ++ di_read_lock_child(d, AuLock_IR); ++ if (unlikely(au_dbrange_test(d))) { ++ di_read_unlock(d, AuLock_IR); ++ continue; ++ } ++ } else { ++ di_write_lock_child(d); ++ if (unlikely(au_dbrange_test(d))) { ++ di_write_unlock(d); ++ continue; ++ } ++ err = au_reval_dpath(d, sigen); ++ if (!err) ++ di_downgrade_lock(d, AuLock_IR); ++ else { ++ di_write_unlock(d); ++ break; ++ } ++ } ++ ++ /* AuDbgDentry(d); */ ++ btop = au_dbtop(d); ++ bbot = au_dbbot(d); ++ if (btop <= bindex ++ && bindex <= bbot ++ && au_h_dptr(d, bindex) ++ && au_test_dbusy(d, btop, bbot)) { ++ err = -EBUSY; ++ AuVerbose(verbose, "busy %pd\n", d); ++ AuDbgDentry(d); ++ } ++ di_read_unlock(d, AuLock_IR); ++ } ++ } ++ ++out_dpages: ++ au_dpages_free(&dpages); ++out: ++ return err; ++} ++ ++static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex, ++ unsigned int sigen, const unsigned int verbose) ++{ ++ int err; ++ unsigned long long max, ull; ++ struct inode *i, **array; ++ aufs_bindex_t btop, bbot; ++ ++ array = au_iarray_alloc(sb, &max); ++ err = PTR_ERR(array); ++ if (IS_ERR(array)) ++ goto out; ++ ++ err = 0; ++ AuDbg("b%d\n", bindex); ++ for (ull = 0; !err && ull < max; ull++) { ++ i = array[ull]; ++ if (unlikely(!i)) ++ break; ++ if (i->i_ino == AUFS_ROOT_INO) ++ continue; ++ ++ /* AuDbgInode(i); */ ++ if (au_iigen(i, NULL) == sigen) ++ ii_read_lock_child(i); ++ else { ++ ii_write_lock_child(i); ++ err = au_refresh_hinode_self(i); ++ au_iigen_dec(i); ++ if (!err) ++ ii_downgrade_lock(i); ++ else { ++ ii_write_unlock(i); ++ break; ++ } ++ } ++ ++ btop = au_ibtop(i); ++ bbot = au_ibbot(i); ++ if (btop <= bindex ++ && bindex <= bbot ++ && au_h_iptr(i, bindex) ++ && au_test_ibusy(i, btop, bbot)) { ++ err = -EBUSY; ++ AuVerbose(verbose, "busy i%lu\n", i->i_ino); ++ AuDbgInode(i); ++ } ++ ii_read_unlock(i); ++ } ++ au_iarray_free(array, max); ++ ++out: ++ return err; ++} ++ ++static int test_children_busy(struct dentry *root, aufs_bindex_t bindex, ++ const unsigned int verbose) ++{ ++ int err; ++ unsigned int sigen; ++ ++ sigen = au_sigen(root->d_sb); ++ DiMustNoWaiters(root); ++ IiMustNoWaiters(d_inode(root)); ++ di_write_unlock(root); ++ err = test_dentry_busy(root, bindex, sigen, verbose); ++ if (!err) ++ err = test_inode_busy(root->d_sb, bindex, sigen, verbose); ++ di_write_lock_child(root); /* aufs_write_lock() calls ..._child() */ ++ ++ return err; ++} ++ ++static int test_dir_busy(struct file *file, aufs_bindex_t br_id, ++ struct file **to_free, int *idx) ++{ ++ int err; ++ unsigned char matched, root; ++ aufs_bindex_t bindex, bbot; ++ struct au_fidir *fidir; ++ struct au_hfile *hfile; ++ ++ err = 0; ++ root = IS_ROOT(file->f_path.dentry); ++ if (root) { ++ get_file(file); ++ to_free[*idx] = file; ++ (*idx)++; ++ goto out; ++ } ++ ++ matched = 0; ++ fidir = au_fi(file)->fi_hdir; ++ AuDebugOn(!fidir); ++ bbot = au_fbbot_dir(file); ++ for (bindex = au_fbtop(file); bindex <= bbot; bindex++) { ++ hfile = fidir->fd_hfile + bindex; ++ if (!hfile->hf_file) ++ continue; ++ ++ if (hfile->hf_br->br_id == br_id) { ++ matched = 1; ++ break; ++ } ++ } ++ if (matched) ++ err = -EBUSY; ++ ++out: ++ return err; ++} ++ ++static int test_file_busy(struct super_block *sb, aufs_bindex_t br_id, ++ struct file **to_free, int opened) ++{ ++ int err, idx; ++ unsigned long long ull, max; ++ aufs_bindex_t btop; ++ struct file *file, **array; ++ struct dentry *root; ++ struct au_hfile *hfile; ++ ++ array = au_farray_alloc(sb, &max); ++ err = PTR_ERR(array); ++ if (IS_ERR(array)) ++ goto out; ++ ++ err = 0; ++ idx = 0; ++ root = sb->s_root; ++ di_write_unlock(root); ++ for (ull = 0; ull < max; ull++) { ++ file = array[ull]; ++ if (unlikely(!file)) ++ break; ++ ++ /* AuDbg("%pD\n", file); */ ++ fi_read_lock(file); ++ btop = au_fbtop(file); ++ if (!d_is_dir(file->f_path.dentry)) { ++ hfile = &au_fi(file)->fi_htop; ++ if (hfile->hf_br->br_id == br_id) ++ err = -EBUSY; ++ } else ++ err = test_dir_busy(file, br_id, to_free, &idx); ++ fi_read_unlock(file); ++ if (unlikely(err)) ++ break; ++ } ++ di_write_lock_child(root); ++ au_farray_free(array, max); ++ AuDebugOn(idx > opened); ++ ++out: ++ return err; ++} ++ ++static void br_del_file(struct file **to_free, unsigned long long opened, ++ aufs_bindex_t br_id) ++{ ++ unsigned long long ull; ++ aufs_bindex_t bindex, btop, bbot, bfound; ++ struct file *file; ++ struct au_fidir *fidir; ++ struct au_hfile *hfile; ++ ++ for (ull = 0; ull < opened; ull++) { ++ file = to_free[ull]; ++ if (unlikely(!file)) ++ break; ++ ++ /* AuDbg("%pD\n", file); */ ++ AuDebugOn(!d_is_dir(file->f_path.dentry)); ++ bfound = -1; ++ fidir = au_fi(file)->fi_hdir; ++ AuDebugOn(!fidir); ++ fi_write_lock(file); ++ btop = au_fbtop(file); ++ bbot = au_fbbot_dir(file); ++ for (bindex = btop; bindex <= bbot; bindex++) { ++ hfile = fidir->fd_hfile + bindex; ++ if (!hfile->hf_file) ++ continue; ++ ++ if (hfile->hf_br->br_id == br_id) { ++ bfound = bindex; ++ break; ++ } ++ } ++ AuDebugOn(bfound < 0); ++ au_set_h_fptr(file, bfound, NULL); ++ if (bfound == btop) { ++ for (btop++; btop <= bbot; btop++) ++ if (au_hf_dir(file, btop)) { ++ au_set_fbtop(file, btop); ++ break; ++ } ++ } ++ fi_write_unlock(file); ++ } ++} ++ ++static void au_br_do_del_brp(struct au_sbinfo *sbinfo, ++ const aufs_bindex_t bindex, ++ const aufs_bindex_t bbot) ++{ ++ struct au_branch **brp, **p; ++ ++ AuRwMustWriteLock(&sbinfo->si_rwsem); ++ ++ brp = sbinfo->si_branch + bindex; ++ if (bindex < bbot) ++ memmove(brp, brp + 1, sizeof(*brp) * (bbot - bindex)); ++ sbinfo->si_branch[0 + bbot] = NULL; ++ sbinfo->si_bbot--; ++ ++ p = au_krealloc(sbinfo->si_branch, sizeof(*p) * bbot, AuGFP_SBILIST, ++ /*may_shrink*/1); ++ if (p) ++ sbinfo->si_branch = p; ++ /* harmless error */ ++} ++ ++static void au_br_do_del_hdp(struct au_dinfo *dinfo, const aufs_bindex_t bindex, ++ const aufs_bindex_t bbot) ++{ ++ struct au_hdentry *hdp, *p; ++ ++ AuRwMustWriteLock(&dinfo->di_rwsem); ++ ++ hdp = au_hdentry(dinfo, bindex); ++ if (bindex < bbot) ++ memmove(hdp, hdp + 1, sizeof(*hdp) * (bbot - bindex)); ++ /* au_h_dentry_init(au_hdentry(dinfo, bbot); */ ++ dinfo->di_bbot--; ++ ++ p = au_krealloc(dinfo->di_hdentry, sizeof(*p) * bbot, AuGFP_SBILIST, ++ /*may_shrink*/1); ++ if (p) ++ dinfo->di_hdentry = p; ++ /* harmless error */ ++} ++ ++static void au_br_do_del_hip(struct au_iinfo *iinfo, const aufs_bindex_t bindex, ++ const aufs_bindex_t bbot) ++{ ++ struct au_hinode *hip, *p; ++ ++ AuRwMustWriteLock(&iinfo->ii_rwsem); ++ ++ hip = au_hinode(iinfo, bindex); ++ if (bindex < bbot) ++ memmove(hip, hip + 1, sizeof(*hip) * (bbot - bindex)); ++ /* au_hinode_init(au_hinode(iinfo, bbot)); */ ++ iinfo->ii_bbot--; ++ ++ p = au_krealloc(iinfo->ii_hinode, sizeof(*p) * bbot, AuGFP_SBILIST, ++ /*may_shrink*/1); ++ if (p) ++ iinfo->ii_hinode = p; ++ /* harmless error */ ++} ++ ++static void au_br_do_del(struct super_block *sb, aufs_bindex_t bindex, ++ struct au_branch *br) ++{ ++ aufs_bindex_t bbot; ++ struct au_sbinfo *sbinfo; ++ struct dentry *root, *h_root; ++ struct inode *inode, *h_inode; ++ struct au_hinode *hinode; ++ ++ SiMustWriteLock(sb); ++ ++ root = sb->s_root; ++ inode = d_inode(root); ++ sbinfo = au_sbi(sb); ++ bbot = sbinfo->si_bbot; ++ ++ h_root = au_h_dptr(root, bindex); ++ hinode = au_hi(inode, bindex); ++ h_inode = au_igrab(hinode->hi_inode); ++ au_hiput(hinode); ++ ++ au_sbilist_lock(); ++ au_br_do_del_brp(sbinfo, bindex, bbot); ++ au_br_do_del_hdp(au_di(root), bindex, bbot); ++ au_br_do_del_hip(au_ii(inode), bindex, bbot); ++ au_sbilist_unlock(); ++ ++ /* ignore an error */ ++ au_dr_br_fin(sb, br); /* always, regardless the mount option */ ++ ++ dput(h_root); ++ iput(h_inode); ++ au_br_do_free(br); ++} ++ ++static unsigned long long empty_cb(struct super_block *sb, void *array, ++ unsigned long long max, void *arg) ++{ ++ return max; ++} ++ ++int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount) ++{ ++ int err, rerr, i; ++ unsigned long long opened; ++ unsigned int mnt_flags; ++ aufs_bindex_t bindex, bbot, br_id; ++ unsigned char do_wh, verbose; ++ struct au_branch *br; ++ struct au_wbr *wbr; ++ struct dentry *root; ++ struct file **to_free; ++ ++ err = 0; ++ opened = 0; ++ to_free = NULL; ++ root = sb->s_root; ++ bindex = au_find_dbindex(root, del->h_path.dentry); ++ if (bindex < 0) { ++ if (remount) ++ goto out; /* success */ ++ err = -ENOENT; ++ pr_err("%s no such branch\n", del->pathname); ++ goto out; ++ } ++ AuDbg("bindex b%d\n", bindex); ++ ++ err = -EBUSY; ++ mnt_flags = au_mntflags(sb); ++ verbose = !!au_opt_test(mnt_flags, VERBOSE); ++ bbot = au_sbbot(sb); ++ if (unlikely(!bbot)) { ++ AuVerbose(verbose, "no more branches left\n"); ++ goto out; ++ } ++ ++ br = au_sbr(sb, bindex); ++ AuDebugOn(!path_equal(&br->br_path, &del->h_path)); ++ if (unlikely(au_lcnt_read(&br->br_count, /*do_rev*/1))) { ++ AuVerbose(verbose, "br %pd2 is busy now\n", del->h_path.dentry); ++ goto out; ++ } ++ ++ br_id = br->br_id; ++ opened = au_lcnt_read(&br->br_nfiles, /*do_rev*/1); ++ if (unlikely(opened)) { ++ to_free = au_array_alloc(&opened, empty_cb, sb, NULL); ++ err = PTR_ERR(to_free); ++ if (IS_ERR(to_free)) ++ goto out; ++ ++ err = test_file_busy(sb, br_id, to_free, opened); ++ if (unlikely(err)) { ++ AuVerbose(verbose, "%llu file(s) opened\n", opened); ++ goto out; ++ } ++ } ++ ++ wbr = br->br_wbr; ++ do_wh = wbr && (wbr->wbr_whbase || wbr->wbr_plink || wbr->wbr_orph); ++ if (do_wh) { ++ /* instead of WbrWhMustWriteLock(wbr) */ ++ SiMustWriteLock(sb); ++ for (i = 0; i < AuBrWh_Last; i++) { ++ dput(wbr->wbr_wh[i]); ++ wbr->wbr_wh[i] = NULL; ++ } ++ } ++ ++ err = test_children_busy(root, bindex, verbose); ++ if (unlikely(err)) { ++ if (do_wh) ++ goto out_wh; ++ goto out; ++ } ++ ++ err = 0; ++ if (to_free) { ++ /* ++ * now we confirmed the branch is deletable. ++ * let's free the remaining opened dirs on the branch. ++ */ ++ di_write_unlock(root); ++ br_del_file(to_free, opened, br_id); ++ di_write_lock_child(root); ++ } ++ ++ sysaufs_brs_del(sb, bindex); /* remove successors */ ++ dbgaufs_xino_del(br); /* remove one */ ++ au_br_do_del(sb, bindex, br); ++ sysaufs_brs_add(sb, bindex); /* append successors */ ++ dbgaufs_brs_add(sb, bindex, /*topdown*/1); /* rename successors */ ++ ++ if (!bindex) { ++ au_cpup_attr_all(d_inode(root), /*force*/1); ++ sb->s_maxbytes = au_sbr_sb(sb, 0)->s_maxbytes; ++ } else ++ au_sub_nlink(d_inode(root), d_inode(del->h_path.dentry)); ++ if (au_opt_test(mnt_flags, PLINK)) ++ au_plink_half_refresh(sb, br_id); ++ ++ goto out; /* success */ ++ ++out_wh: ++ /* revert */ ++ rerr = au_br_init_wh(sb, br, br->br_perm); ++ if (rerr) ++ pr_warn("failed re-creating base whiteout, %s. (%d)\n", ++ del->pathname, rerr); ++out: ++ if (to_free) ++ au_farray_free(to_free, opened); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_ibusy(struct super_block *sb, struct aufs_ibusy __user *arg) ++{ ++ int err; ++ aufs_bindex_t btop, bbot; ++ struct aufs_ibusy ibusy; ++ struct inode *inode, *h_inode; ++ ++ err = -EPERM; ++ if (unlikely(!capable(CAP_SYS_ADMIN))) ++ goto out; ++ ++ err = copy_from_user(&ibusy, arg, sizeof(ibusy)); ++ if (!err) ++ /* VERIFY_WRITE */ ++ err = !access_ok(&arg->h_ino, sizeof(arg->h_ino)); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ goto out; ++ } ++ ++ err = -EINVAL; ++ si_read_lock(sb, AuLock_FLUSH); ++ if (unlikely(ibusy.bindex < 0 || ibusy.bindex > au_sbbot(sb))) ++ goto out_unlock; ++ ++ err = 0; ++ ibusy.h_ino = 0; /* invalid */ ++ inode = ilookup(sb, ibusy.ino); ++ if (!inode ++ || inode->i_ino == AUFS_ROOT_INO ++ || au_is_bad_inode(inode)) ++ goto out_unlock; ++ ++ ii_read_lock_child(inode); ++ btop = au_ibtop(inode); ++ bbot = au_ibbot(inode); ++ if (btop <= ibusy.bindex && ibusy.bindex <= bbot) { ++ h_inode = au_h_iptr(inode, ibusy.bindex); ++ if (h_inode && au_test_ibusy(inode, btop, bbot)) ++ ibusy.h_ino = h_inode->i_ino; ++ } ++ ii_read_unlock(inode); ++ iput(inode); ++ ++out_unlock: ++ si_read_unlock(sb); ++ if (!err) { ++ err = __put_user(ibusy.h_ino, &arg->h_ino); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ } ++ } ++out: ++ return err; ++} ++ ++long au_ibusy_ioctl(struct file *file, unsigned long arg) ++{ ++ return au_ibusy(file->f_path.dentry->d_sb, (void __user *)arg); ++} ++ ++#ifdef CONFIG_COMPAT ++long au_ibusy_compat_ioctl(struct file *file, unsigned long arg) ++{ ++ return au_ibusy(file->f_path.dentry->d_sb, compat_ptr(arg)); ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * change a branch permission ++ */ ++ ++static void au_warn_ima(void) ++{ ++#ifdef CONFIG_IMA ++ /* since it doesn't support mark_files_ro() */ ++ AuWarn1("RW -> RO makes IMA to produce wrong message\n"); ++#endif ++} ++ ++static int do_need_sigen_inc(int a, int b) ++{ ++ return au_br_whable(a) && !au_br_whable(b); ++} ++ ++static int need_sigen_inc(int old, int new) ++{ ++ return do_need_sigen_inc(old, new) ++ || do_need_sigen_inc(new, old); ++} ++ ++static int au_br_mod_files_ro(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ int err, do_warn; ++ unsigned int mnt_flags; ++ unsigned long long ull, max; ++ aufs_bindex_t br_id; ++ unsigned char verbose, writer; ++ struct file *file, *hf, **array; ++ struct au_hfile *hfile; ++ struct inode *h_inode; ++ ++ mnt_flags = au_mntflags(sb); ++ verbose = !!au_opt_test(mnt_flags, VERBOSE); ++ ++ array = au_farray_alloc(sb, &max); ++ err = PTR_ERR(array); ++ if (IS_ERR(array)) ++ goto out; ++ ++ do_warn = 0; ++ br_id = au_sbr_id(sb, bindex); ++ for (ull = 0; ull < max; ull++) { ++ file = array[ull]; ++ if (unlikely(!file)) ++ break; ++ ++ /* AuDbg("%pD\n", file); */ ++ fi_read_lock(file); ++ if (unlikely(au_test_mmapped(file))) { ++ err = -EBUSY; ++ AuVerbose(verbose, "mmapped %pD\n", file); ++ AuDbgFile(file); ++ FiMustNoWaiters(file); ++ fi_read_unlock(file); ++ goto out_array; ++ } ++ ++ hfile = &au_fi(file)->fi_htop; ++ hf = hfile->hf_file; ++ if (!d_is_reg(file->f_path.dentry) ++ || !(file->f_mode & FMODE_WRITE) ++ || hfile->hf_br->br_id != br_id ++ || !(hf->f_mode & FMODE_WRITE)) ++ array[ull] = NULL; ++ else { ++ do_warn = 1; ++ get_file(file); ++ } ++ ++ FiMustNoWaiters(file); ++ fi_read_unlock(file); ++ fput(file); ++ } ++ ++ err = 0; ++ if (do_warn) ++ au_warn_ima(); ++ ++ for (ull = 0; ull < max; ull++) { ++ file = array[ull]; ++ if (!file) ++ continue; ++ ++ /* todo: already flushed? */ ++ /* ++ * fs/super.c:mark_files_ro() is gone, but aufs keeps its ++ * approach which resets f_mode and calls mnt_drop_write() and ++ * file_release_write() for each file, because the branch ++ * attribute in aufs world is totally different from the native ++ * fs rw/ro mode. ++ */ ++ /* fi_read_lock(file); */ ++ hfile = &au_fi(file)->fi_htop; ++ hf = hfile->hf_file; ++ /* fi_read_unlock(file); */ ++ spin_lock(&hf->f_lock); ++ writer = !!(hf->f_mode & FMODE_WRITER); ++ hf->f_mode &= ~(FMODE_WRITE | FMODE_WRITER); ++ spin_unlock(&hf->f_lock); ++ if (writer) { ++ h_inode = file_inode(hf); ++ if (hf->f_mode & FMODE_READ) ++ i_readcount_inc(h_inode); ++ put_write_access(h_inode); ++ __mnt_drop_write(hf->f_path.mnt); ++ } ++ } ++ ++out_array: ++ au_farray_free(array, max); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount, ++ int *do_refresh) ++{ ++ int err, rerr; ++ aufs_bindex_t bindex; ++ struct dentry *root; ++ struct au_branch *br; ++ struct au_br_fhsm *bf; ++ ++ root = sb->s_root; ++ bindex = au_find_dbindex(root, mod->h_root); ++ if (bindex < 0) { ++ if (remount) ++ return 0; /* success */ ++ err = -ENOENT; ++ pr_err("%s no such branch\n", mod->path); ++ goto out; ++ } ++ AuDbg("bindex b%d\n", bindex); ++ ++ err = test_br(d_inode(mod->h_root), mod->perm, mod->path); ++ if (unlikely(err)) ++ goto out; ++ ++ br = au_sbr(sb, bindex); ++ AuDebugOn(mod->h_root != au_br_dentry(br)); ++ if (br->br_perm == mod->perm) ++ return 0; /* success */ ++ ++ /* pre-allocate for non-fhsm --> fhsm */ ++ bf = NULL; ++ if (!au_br_fhsm(br->br_perm) && au_br_fhsm(mod->perm)) { ++ err = au_fhsm_br_alloc(br); ++ if (unlikely(err)) ++ goto out; ++ bf = br->br_fhsm; ++ br->br_fhsm = NULL; ++ } ++ ++ if (au_br_writable(br->br_perm)) { ++ /* remove whiteout base */ ++ err = au_br_init_wh(sb, br, mod->perm); ++ if (unlikely(err)) ++ goto out_bf; ++ ++ if (!au_br_writable(mod->perm)) { ++ /* rw --> ro, file might be mmapped */ ++ DiMustNoWaiters(root); ++ IiMustNoWaiters(d_inode(root)); ++ di_write_unlock(root); ++ err = au_br_mod_files_ro(sb, bindex); ++ /* aufs_write_lock() calls ..._child() */ ++ di_write_lock_child(root); ++ ++ if (unlikely(err)) { ++ rerr = -ENOMEM; ++ br->br_wbr = kzalloc(sizeof(*br->br_wbr), ++ GFP_NOFS); ++ if (br->br_wbr) ++ rerr = au_wbr_init(br, sb, br->br_perm); ++ if (unlikely(rerr)) { ++ AuIOErr("nested error %d (%d)\n", ++ rerr, err); ++ br->br_perm = mod->perm; ++ } ++ } ++ } ++ } else if (au_br_writable(mod->perm)) { ++ /* ro --> rw */ ++ err = -ENOMEM; ++ br->br_wbr = kzalloc(sizeof(*br->br_wbr), GFP_NOFS); ++ if (br->br_wbr) { ++ err = au_wbr_init(br, sb, mod->perm); ++ if (unlikely(err)) { ++ au_kfree_rcu(br->br_wbr); ++ br->br_wbr = NULL; ++ } ++ } ++ } ++ if (unlikely(err)) ++ goto out_bf; ++ ++ if (au_br_fhsm(br->br_perm)) { ++ if (!au_br_fhsm(mod->perm)) { ++ /* fhsm --> non-fhsm */ ++ au_br_fhsm_fin(br->br_fhsm); ++ au_kfree_rcu(br->br_fhsm); ++ br->br_fhsm = NULL; ++ } ++ } else if (au_br_fhsm(mod->perm)) ++ /* non-fhsm --> fhsm */ ++ br->br_fhsm = bf; ++ ++ *do_refresh |= need_sigen_inc(br->br_perm, mod->perm); ++ br->br_perm = mod->perm; ++ goto out; /* success */ ++ ++out_bf: ++ au_kfree_try_rcu(bf); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_br_stfs(struct au_branch *br, struct aufs_stfs *stfs) ++{ ++ int err; ++ struct kstatfs kstfs; ++ ++ err = vfs_statfs(&br->br_path, &kstfs); ++ if (!err) { ++ stfs->f_blocks = kstfs.f_blocks; ++ stfs->f_bavail = kstfs.f_bavail; ++ stfs->f_files = kstfs.f_files; ++ stfs->f_ffree = kstfs.f_ffree; ++ } ++ ++ return err; ++} +diff --git a/fs/aufs/branch.h b/fs/aufs/branch.h +new file mode 100644 +index 000000000000..0bac9a6c9557 +--- /dev/null ++++ b/fs/aufs/branch.h +@@ -0,0 +1,353 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * branch filesystems and xino for them ++ */ ++ ++#ifndef __AUFS_BRANCH_H__ ++#define __AUFS_BRANCH_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include "dirren.h" ++#include "dynop.h" ++#include "lcnt.h" ++#include "rwsem.h" ++#include "super.h" ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* a xino file */ ++struct au_xino { ++ struct file **xi_file; ++ unsigned int xi_nfile; ++ ++ struct { ++ spinlock_t spin; ++ ino_t *array; ++ int total; ++ /* reserved for future use */ ++ /* unsigned long *bitmap; */ ++ wait_queue_head_t wqh; ++ } xi_nondir; ++ ++ struct mutex xi_mtx; /* protects xi_file array */ ++ struct hlist_bl_head xi_writing; ++ ++ atomic_t xi_truncating; ++ ++ struct kref xi_kref; ++}; ++ ++/* File-based Hierarchical Storage Management */ ++struct au_br_fhsm { ++#ifdef CONFIG_AUFS_FHSM ++ struct mutex bf_lock; ++ unsigned long bf_jiffy; ++ struct aufs_stfs bf_stfs; ++ int bf_readable; ++#endif ++}; ++ ++/* members for writable branch only */ ++enum {AuBrWh_BASE, AuBrWh_PLINK, AuBrWh_ORPH, AuBrWh_Last}; ++struct au_wbr { ++ struct au_rwsem wbr_wh_rwsem; ++ struct dentry *wbr_wh[AuBrWh_Last]; ++ atomic_t wbr_wh_running; ++#define wbr_whbase wbr_wh[AuBrWh_BASE] /* whiteout base */ ++#define wbr_plink wbr_wh[AuBrWh_PLINK] /* pseudo-link dir */ ++#define wbr_orph wbr_wh[AuBrWh_ORPH] /* dir for orphans */ ++ ++ /* mfs mode */ ++ unsigned long long wbr_bytes; ++}; ++ ++/* ext2 has 3 types of operations at least, ext3 has 4 */ ++#define AuBrDynOp (AuDyLast * 4) ++ ++#ifdef CONFIG_AUFS_HFSNOTIFY ++/* support for asynchronous destruction */ ++struct au_br_hfsnotify { ++ struct fsnotify_group *hfsn_group; ++}; ++#endif ++ ++/* sysfs entries */ ++struct au_brsysfs { ++ char name[16]; ++ struct attribute attr; ++}; ++ ++enum { ++ AuBrSysfs_BR, ++ AuBrSysfs_BRID, ++ AuBrSysfs_Last ++}; ++ ++/* protected by superblock rwsem */ ++struct au_branch { ++ struct au_xino *br_xino; ++ ++ aufs_bindex_t br_id; ++ ++ int br_perm; ++ struct path br_path; ++ spinlock_t br_dykey_lock; ++ struct au_dykey *br_dykey[AuBrDynOp]; ++ au_lcnt_t br_nfiles; /* opened files */ ++ au_lcnt_t br_count; /* in-use for other */ ++ ++ struct au_wbr *br_wbr; ++ struct au_br_fhsm *br_fhsm; ++ ++#ifdef CONFIG_AUFS_HFSNOTIFY ++ struct au_br_hfsnotify *br_hfsn; ++#endif ++ ++#ifdef CONFIG_SYSFS ++ /* entries under sysfs per mount-point */ ++ struct au_brsysfs br_sysfs[AuBrSysfs_Last]; ++#endif ++ ++#ifdef CONFIG_DEBUG_FS ++ struct dentry *br_dbgaufs; /* xino */ ++#endif ++ ++ struct au_dr_br br_dirren; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct vfsmount *au_br_mnt(struct au_branch *br) ++{ ++ return br->br_path.mnt; ++} ++ ++static inline struct dentry *au_br_dentry(struct au_branch *br) ++{ ++ return br->br_path.dentry; ++} ++ ++static inline struct super_block *au_br_sb(struct au_branch *br) ++{ ++ return au_br_mnt(br)->mnt_sb; ++} ++ ++static inline int au_br_rdonly(struct au_branch *br) ++{ ++ return (sb_rdonly(au_br_sb(br)) ++ || !au_br_writable(br->br_perm)) ++ ? -EROFS : 0; ++} ++ ++static inline int au_br_hnotifyable(int brperm __maybe_unused) ++{ ++#ifdef CONFIG_AUFS_HNOTIFY ++ return !(brperm & AuBrPerm_RR); ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_br_test_oflag(int oflag, struct au_branch *br) ++{ ++ int err, exec_flag; ++ ++ err = 0; ++ exec_flag = oflag & __FMODE_EXEC; ++ if (unlikely(exec_flag && path_noexec(&br->br_path))) ++ err = -EACCES; ++ ++ return err; ++} ++ ++static inline void au_xino_get(struct au_branch *br) ++{ ++ struct au_xino *xi; ++ ++ xi = br->br_xino; ++ if (xi) ++ kref_get(&xi->xi_kref); ++} ++ ++static inline int au_xino_count(struct au_branch *br) ++{ ++ int v; ++ struct au_xino *xi; ++ ++ v = 0; ++ xi = br->br_xino; ++ if (xi) ++ v = kref_read(&xi->xi_kref); ++ ++ return v; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* branch.c */ ++struct au_sbinfo; ++void au_br_free(struct au_sbinfo *sinfo); ++int au_br_index(struct super_block *sb, aufs_bindex_t br_id); ++struct au_opt_add; ++int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount); ++struct au_opt_del; ++int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount); ++long au_ibusy_ioctl(struct file *file, unsigned long arg); ++#ifdef CONFIG_COMPAT ++long au_ibusy_compat_ioctl(struct file *file, unsigned long arg); ++#endif ++struct au_opt_mod; ++int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount, ++ int *do_refresh); ++struct aufs_stfs; ++int au_br_stfs(struct au_branch *br, struct aufs_stfs *stfs); ++ ++/* xino.c */ ++static const loff_t au_loff_max = LLONG_MAX; ++ ++aufs_bindex_t au_xi_root(struct super_block *sb, struct dentry *dentry); ++struct file *au_xino_create(struct super_block *sb, char *fpath, int silent, ++ int wbrtop); ++struct file *au_xino_create2(struct super_block *sb, struct path *base, ++ struct file *copy_src); ++struct au_xi_new { ++ struct au_xino *xi; /* switch between xino and xigen */ ++ int idx; ++ struct path *base; ++ struct file *copy_src; ++}; ++struct file *au_xi_new(struct super_block *sb, struct au_xi_new *xinew); ++ ++int au_xino_read(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t *ino); ++int au_xino_write(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t ino); ++ssize_t xino_fread(vfs_readf_t func, struct file *file, void *buf, size_t size, ++ loff_t *pos); ++ssize_t xino_fwrite(vfs_writef_t func, struct file *file, void *buf, ++ size_t size, loff_t *pos); ++ ++int au_xib_trunc(struct super_block *sb); ++int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex, int idx_begin); ++ ++struct au_xino *au_xino_alloc(unsigned int nfile); ++int au_xino_put(struct au_branch *br); ++struct file *au_xino_file1(struct au_xino *xi); ++ ++struct au_opt_xino; ++void au_xino_clr(struct super_block *sb); ++int au_xino_set(struct super_block *sb, struct au_opt_xino *xiopt, int remount); ++struct file *au_xino_def(struct super_block *sb); ++int au_xino_init_br(struct super_block *sb, struct au_branch *br, ino_t hino, ++ struct path *base); ++ ++ino_t au_xino_new_ino(struct super_block *sb); ++void au_xino_delete_inode(struct inode *inode, const int unlinked); ++ ++void au_xinondir_leave(struct super_block *sb, aufs_bindex_t bindex, ++ ino_t h_ino, int idx); ++int au_xinondir_enter(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ int *idx); ++ ++int au_xino_path(struct seq_file *seq, struct file *file); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* @idx is signed to accept -1 meaning the first file */ ++static inline struct file *au_xino_file(struct au_xino *xi, int idx) ++{ ++ struct file *file; ++ ++ file = NULL; ++ if (!xi) ++ goto out; ++ ++ if (idx >= 0) { ++ if (idx < xi->xi_nfile) ++ file = xi->xi_file[idx]; ++ } else ++ file = au_xino_file1(xi); ++ ++out: ++ return file; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* Superblock to branch */ ++static inline ++aufs_bindex_t au_sbr_id(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_sbr(sb, bindex)->br_id; ++} ++ ++static inline ++struct vfsmount *au_sbr_mnt(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_br_mnt(au_sbr(sb, bindex)); ++} ++ ++static inline ++struct super_block *au_sbr_sb(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_br_sb(au_sbr(sb, bindex)); ++} ++ ++static inline int au_sbr_perm(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_sbr(sb, bindex)->br_perm; ++} ++ ++static inline int au_sbr_whable(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_br_whable(au_sbr_perm(sb, bindex)); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define wbr_wh_read_lock(wbr) au_rw_read_lock(&(wbr)->wbr_wh_rwsem) ++#define wbr_wh_write_lock(wbr) au_rw_write_lock(&(wbr)->wbr_wh_rwsem) ++#define wbr_wh_read_trylock(wbr) au_rw_read_trylock(&(wbr)->wbr_wh_rwsem) ++#define wbr_wh_write_trylock(wbr) au_rw_write_trylock(&(wbr)->wbr_wh_rwsem) ++/* ++#define wbr_wh_read_trylock_nested(wbr) \ ++ au_rw_read_trylock_nested(&(wbr)->wbr_wh_rwsem) ++#define wbr_wh_write_trylock_nested(wbr) \ ++ au_rw_write_trylock_nested(&(wbr)->wbr_wh_rwsem) ++*/ ++ ++#define wbr_wh_read_unlock(wbr) au_rw_read_unlock(&(wbr)->wbr_wh_rwsem) ++#define wbr_wh_write_unlock(wbr) au_rw_write_unlock(&(wbr)->wbr_wh_rwsem) ++#define wbr_wh_downgrade_lock(wbr) au_rw_dgrade_lock(&(wbr)->wbr_wh_rwsem) ++ ++#define WbrWhMustNoWaiters(wbr) AuRwMustNoWaiters(&(wbr)->wbr_wh_rwsem) ++#define WbrWhMustAnyLock(wbr) AuRwMustAnyLock(&(wbr)->wbr_wh_rwsem) ++#define WbrWhMustWriteLock(wbr) AuRwMustWriteLock(&(wbr)->wbr_wh_rwsem) ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_FHSM ++static inline void au_br_fhsm_init(struct au_br_fhsm *brfhsm) ++{ ++ mutex_init(&brfhsm->bf_lock); ++ brfhsm->bf_jiffy = 0; ++ brfhsm->bf_readable = 0; ++} ++ ++static inline void au_br_fhsm_fin(struct au_br_fhsm *brfhsm) ++{ ++ mutex_destroy(&brfhsm->bf_lock); ++} ++#else ++AuStubVoid(au_br_fhsm_init, struct au_br_fhsm *brfhsm) ++AuStubVoid(au_br_fhsm_fin, struct au_br_fhsm *brfhsm) ++#endif ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_BRANCH_H__ */ +diff --git a/fs/aufs/cpup.c b/fs/aufs/cpup.c +new file mode 100644 +index 000000000000..69a60ddc3474 +--- /dev/null ++++ b/fs/aufs/cpup.c +@@ -0,0 +1,1445 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * copy-up functions, see wbr_policy.c for copy-down ++ */ ++ ++#include ++#include ++#include ++#include "aufs.h" ++ ++void au_cpup_attr_flags(struct inode *dst, unsigned int iflags) ++{ ++ const unsigned int mask = S_DEAD | S_SWAPFILE | S_PRIVATE ++ | S_NOATIME | S_NOCMTIME | S_AUTOMOUNT; ++ ++ BUILD_BUG_ON(sizeof(iflags) != sizeof(dst->i_flags)); ++ ++ dst->i_flags |= iflags & ~mask; ++ if (au_test_fs_notime(dst->i_sb)) ++ dst->i_flags |= S_NOATIME | S_NOCMTIME; ++} ++ ++void au_cpup_attr_timesizes(struct inode *inode) ++{ ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, au_ibtop(inode)); ++ fsstack_copy_attr_times(inode, h_inode); ++ fsstack_copy_inode_size(inode, h_inode); ++} ++ ++void au_cpup_attr_nlink(struct inode *inode, int force) ++{ ++ struct inode *h_inode; ++ struct super_block *sb; ++ aufs_bindex_t bindex, bbot; ++ ++ sb = inode->i_sb; ++ bindex = au_ibtop(inode); ++ h_inode = au_h_iptr(inode, bindex); ++ if (!force ++ && !S_ISDIR(h_inode->i_mode) ++ && au_opt_test(au_mntflags(sb), PLINK) ++ && au_plink_test(inode)) ++ return; ++ ++ /* ++ * 0 can happen in revalidating. ++ * h_inode->i_mutex may not be held here, but it is harmless since once ++ * i_nlink reaches 0, it will never become positive except O_TMPFILE ++ * case. ++ * todo: O_TMPFILE+linkat(AT_SYMLINK_FOLLOW) bypassing aufs may cause ++ * the incorrect link count. ++ */ ++ set_nlink(inode, h_inode->i_nlink); ++ ++ /* ++ * fewer nlink makes find(1) noisy, but larger nlink doesn't. ++ * it may includes whplink directory. ++ */ ++ if (S_ISDIR(h_inode->i_mode)) { ++ bbot = au_ibbot(inode); ++ for (bindex++; bindex <= bbot; bindex++) { ++ h_inode = au_h_iptr(inode, bindex); ++ if (h_inode) ++ au_add_nlink(inode, h_inode); ++ } ++ } ++} ++ ++void au_cpup_attr_changeable(struct inode *inode) ++{ ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, au_ibtop(inode)); ++ inode->i_mode = h_inode->i_mode; ++ inode->i_uid = h_inode->i_uid; ++ inode->i_gid = h_inode->i_gid; ++ au_cpup_attr_timesizes(inode); ++ au_cpup_attr_flags(inode, h_inode->i_flags); ++} ++ ++void au_cpup_igen(struct inode *inode, struct inode *h_inode) ++{ ++ struct au_iinfo *iinfo = au_ii(inode); ++ ++ IiMustWriteLock(inode); ++ ++ iinfo->ii_higen = h_inode->i_generation; ++ iinfo->ii_hsb1 = h_inode->i_sb; ++} ++ ++void au_cpup_attr_all(struct inode *inode, int force) ++{ ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, au_ibtop(inode)); ++ au_cpup_attr_changeable(inode); ++ if (inode->i_nlink > 0) ++ au_cpup_attr_nlink(inode, force); ++ inode->i_rdev = h_inode->i_rdev; ++ inode->i_blkbits = h_inode->i_blkbits; ++ au_cpup_igen(inode, h_inode); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* Note: dt_dentry and dt_h_dentry are not dget/dput-ed */ ++ ++/* keep the timestamps of the parent dir when cpup */ ++void au_dtime_store(struct au_dtime *dt, struct dentry *dentry, ++ struct path *h_path) ++{ ++ struct inode *h_inode; ++ ++ dt->dt_dentry = dentry; ++ dt->dt_h_path = *h_path; ++ h_inode = d_inode(h_path->dentry); ++ dt->dt_atime = h_inode->i_atime; ++ dt->dt_mtime = h_inode->i_mtime; ++ /* smp_mb(); */ ++} ++ ++void au_dtime_revert(struct au_dtime *dt) ++{ ++ struct iattr attr; ++ int err; ++ ++ attr.ia_atime = dt->dt_atime; ++ attr.ia_mtime = dt->dt_mtime; ++ attr.ia_valid = ATTR_FORCE | ATTR_MTIME | ATTR_MTIME_SET ++ | ATTR_ATIME | ATTR_ATIME_SET; ++ ++ /* no delegation since this is a directory */ ++ err = vfsub_notify_change(&dt->dt_h_path, &attr, /*delegated*/NULL); ++ if (unlikely(err)) ++ pr_warn("restoring timestamps failed(%d). ignored\n", err); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* internal use only */ ++struct au_cpup_reg_attr { ++ int valid; ++ struct kstat st; ++ unsigned int iflags; /* inode->i_flags */ ++}; ++ ++static noinline_for_stack ++int cpup_iattr(struct dentry *dst, aufs_bindex_t bindex, struct dentry *h_src, ++ struct au_cpup_reg_attr *h_src_attr) ++{ ++ int err, sbits, icex; ++ unsigned int mnt_flags; ++ unsigned char verbose; ++ struct iattr ia; ++ struct path h_path; ++ struct inode *h_isrc, *h_idst; ++ struct kstat *h_st; ++ struct au_branch *br; ++ ++ h_path.dentry = au_h_dptr(dst, bindex); ++ h_idst = d_inode(h_path.dentry); ++ br = au_sbr(dst->d_sb, bindex); ++ h_path.mnt = au_br_mnt(br); ++ h_isrc = d_inode(h_src); ++ ia.ia_valid = ATTR_FORCE | ATTR_UID | ATTR_GID ++ | ATTR_ATIME | ATTR_MTIME ++ | ATTR_ATIME_SET | ATTR_MTIME_SET; ++ if (h_src_attr && h_src_attr->valid) { ++ h_st = &h_src_attr->st; ++ ia.ia_uid = h_st->uid; ++ ia.ia_gid = h_st->gid; ++ ia.ia_atime = h_st->atime; ++ ia.ia_mtime = h_st->mtime; ++ if (h_idst->i_mode != h_st->mode ++ && !S_ISLNK(h_idst->i_mode)) { ++ ia.ia_valid |= ATTR_MODE; ++ ia.ia_mode = h_st->mode; ++ } ++ sbits = !!(h_st->mode & (S_ISUID | S_ISGID)); ++ au_cpup_attr_flags(h_idst, h_src_attr->iflags); ++ } else { ++ ia.ia_uid = h_isrc->i_uid; ++ ia.ia_gid = h_isrc->i_gid; ++ ia.ia_atime = h_isrc->i_atime; ++ ia.ia_mtime = h_isrc->i_mtime; ++ if (h_idst->i_mode != h_isrc->i_mode ++ && !S_ISLNK(h_idst->i_mode)) { ++ ia.ia_valid |= ATTR_MODE; ++ ia.ia_mode = h_isrc->i_mode; ++ } ++ sbits = !!(h_isrc->i_mode & (S_ISUID | S_ISGID)); ++ au_cpup_attr_flags(h_idst, h_isrc->i_flags); ++ } ++ /* no delegation since it is just created */ ++ err = vfsub_notify_change(&h_path, &ia, /*delegated*/NULL); ++ ++ /* is this nfs only? */ ++ if (!err && sbits && au_test_nfs(h_path.dentry->d_sb)) { ++ ia.ia_valid = ATTR_FORCE | ATTR_MODE; ++ ia.ia_mode = h_isrc->i_mode; ++ err = vfsub_notify_change(&h_path, &ia, /*delegated*/NULL); ++ } ++ ++ icex = br->br_perm & AuBrAttr_ICEX; ++ if (!err) { ++ mnt_flags = au_mntflags(dst->d_sb); ++ verbose = !!au_opt_test(mnt_flags, VERBOSE); ++ err = au_cpup_xattr(h_path.dentry, h_src, icex, verbose); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_do_copy_file(struct file *dst, struct file *src, loff_t len, ++ char *buf, unsigned long blksize) ++{ ++ int err; ++ size_t sz, rbytes, wbytes; ++ unsigned char all_zero; ++ char *p, *zp; ++ struct inode *h_inode; ++ /* reduce stack usage */ ++ struct iattr *ia; ++ ++ zp = page_address(ZERO_PAGE(0)); ++ if (unlikely(!zp)) ++ return -ENOMEM; /* possible? */ ++ ++ err = 0; ++ all_zero = 0; ++ while (len) { ++ AuDbg("len %lld\n", len); ++ sz = blksize; ++ if (len < blksize) ++ sz = len; ++ ++ rbytes = 0; ++ /* todo: signal_pending? */ ++ while (!rbytes || err == -EAGAIN || err == -EINTR) { ++ rbytes = vfsub_read_k(src, buf, sz, &src->f_pos); ++ err = rbytes; ++ } ++ if (unlikely(err < 0)) ++ break; ++ ++ all_zero = 0; ++ if (len >= rbytes && rbytes == blksize) ++ all_zero = !memcmp(buf, zp, rbytes); ++ if (!all_zero) { ++ wbytes = rbytes; ++ p = buf; ++ while (wbytes) { ++ size_t b; ++ ++ b = vfsub_write_k(dst, p, wbytes, &dst->f_pos); ++ err = b; ++ /* todo: signal_pending? */ ++ if (unlikely(err == -EAGAIN || err == -EINTR)) ++ continue; ++ if (unlikely(err < 0)) ++ break; ++ wbytes -= b; ++ p += b; ++ } ++ if (unlikely(err < 0)) ++ break; ++ } else { ++ loff_t res; ++ ++ AuLabel(hole); ++ res = vfsub_llseek(dst, rbytes, SEEK_CUR); ++ err = res; ++ if (unlikely(res < 0)) ++ break; ++ } ++ len -= rbytes; ++ err = 0; ++ } ++ ++ /* the last block may be a hole */ ++ if (!err && all_zero) { ++ AuLabel(last hole); ++ ++ err = 1; ++ if (au_test_nfs(dst->f_path.dentry->d_sb)) { ++ /* nfs requires this step to make last hole */ ++ /* is this only nfs? */ ++ do { ++ /* todo: signal_pending? */ ++ err = vfsub_write_k(dst, "\0", 1, &dst->f_pos); ++ } while (err == -EAGAIN || err == -EINTR); ++ if (err == 1) ++ dst->f_pos--; ++ } ++ ++ if (err == 1) { ++ ia = (void *)buf; ++ ia->ia_size = dst->f_pos; ++ ia->ia_valid = ATTR_SIZE | ATTR_FILE; ++ ia->ia_file = dst; ++ h_inode = file_inode(dst); ++ inode_lock_nested(h_inode, AuLsc_I_CHILD2); ++ /* no delegation since it is just created */ ++ err = vfsub_notify_change(&dst->f_path, ia, ++ /*delegated*/NULL); ++ inode_unlock(h_inode); ++ } ++ } ++ ++ return err; ++} ++ ++int au_copy_file(struct file *dst, struct file *src, loff_t len) ++{ ++ int err; ++ unsigned long blksize; ++ unsigned char do_kfree; ++ char *buf; ++ struct super_block *h_sb; ++ ++ err = -ENOMEM; ++ h_sb = file_inode(dst)->i_sb; ++ blksize = h_sb->s_blocksize; ++ if (!blksize || PAGE_SIZE < blksize) ++ blksize = PAGE_SIZE; ++ AuDbg("blksize %lu\n", blksize); ++ do_kfree = (blksize != PAGE_SIZE && blksize >= sizeof(struct iattr *)); ++ if (do_kfree) ++ buf = kmalloc(blksize, GFP_NOFS); ++ else ++ buf = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!buf)) ++ goto out; ++ ++ if (len > (1 << 22)) ++ AuDbg("copying a large file %lld\n", (long long)len); ++ ++ src->f_pos = 0; ++ dst->f_pos = 0; ++ err = au_do_copy_file(dst, src, len, buf, blksize); ++ if (do_kfree) { ++ AuDebugOn(!au_kfree_do_sz_test(blksize)); ++ au_kfree_do_rcu(buf); ++ } else ++ free_page((unsigned long)buf); ++ ++out: ++ return err; ++} ++ ++static int au_do_copy(struct file *dst, struct file *src, loff_t len) ++{ ++ int err; ++ struct super_block *h_src_sb; ++ struct inode *h_src_inode; ++ ++ h_src_inode = file_inode(src); ++ h_src_sb = h_src_inode->i_sb; ++ ++ /* XFS acquires inode_lock */ ++ if (!au_test_xfs(h_src_sb)) ++ err = au_copy_file(dst, src, len); ++ else { ++ inode_unlock_shared(h_src_inode); ++ err = au_copy_file(dst, src, len); ++ inode_lock_shared_nested(h_src_inode, AuLsc_I_CHILD); ++ } ++ ++ return err; ++} ++ ++static int au_clone_or_copy(struct file *dst, struct file *src, loff_t len) ++{ ++ int err; ++ loff_t lo; ++ struct super_block *h_src_sb; ++ struct inode *h_src_inode; ++ ++ h_src_inode = file_inode(src); ++ h_src_sb = h_src_inode->i_sb; ++ if (h_src_sb != file_inode(dst)->i_sb ++ || !dst->f_op->remap_file_range) { ++ err = au_do_copy(dst, src, len); ++ goto out; ++ } ++ ++ if (!au_test_nfs(h_src_sb)) { ++ inode_unlock_shared(h_src_inode); ++ lo = vfsub_clone_file_range(src, dst, len); ++ inode_lock_shared_nested(h_src_inode, AuLsc_I_CHILD); ++ } else ++ lo = vfsub_clone_file_range(src, dst, len); ++ if (lo == len) { ++ err = 0; ++ goto out; /* success */ ++ } else if (lo >= 0) ++ /* todo: possible? */ ++ /* paritially succeeded */ ++ AuDbg("lo %lld, len %lld. Retrying.\n", lo, len); ++ else if (lo != -EOPNOTSUPP) { ++ /* older XFS has a condition in cloning */ ++ err = lo; ++ goto out; ++ } ++ ++ /* the backend fs on NFS may not support cloning */ ++ err = au_do_copy(dst, src, len); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ++ * to support a sparse file which is opened with O_APPEND, ++ * we need to close the file. ++ */ ++static int au_cp_regular(struct au_cp_generic *cpg) ++{ ++ int err, i; ++ enum { SRC, DST }; ++ struct { ++ aufs_bindex_t bindex; ++ unsigned int flags; ++ struct dentry *dentry; ++ int force_wr; ++ struct file *file; ++ } *f, file[] = { ++ { ++ .bindex = cpg->bsrc, ++ .flags = O_RDONLY | O_NOATIME | O_LARGEFILE, ++ }, ++ { ++ .bindex = cpg->bdst, ++ .flags = O_WRONLY | O_NOATIME | O_LARGEFILE, ++ .force_wr = !!au_ftest_cpup(cpg->flags, RWDST), ++ } ++ }; ++ struct au_branch *br; ++ struct super_block *sb, *h_src_sb; ++ struct inode *h_src_inode; ++ struct task_struct *tsk = current; ++ ++ /* bsrc branch can be ro/rw. */ ++ sb = cpg->dentry->d_sb; ++ f = file; ++ for (i = 0; i < 2; i++, f++) { ++ f->dentry = au_h_dptr(cpg->dentry, f->bindex); ++ f->file = au_h_open(cpg->dentry, f->bindex, f->flags, ++ /*file*/NULL, f->force_wr); ++ if (IS_ERR(f->file)) { ++ err = PTR_ERR(f->file); ++ if (i == SRC) ++ goto out; ++ else ++ goto out_src; ++ } ++ } ++ ++ /* try stopping to update while we copyup */ ++ h_src_inode = d_inode(file[SRC].dentry); ++ h_src_sb = h_src_inode->i_sb; ++ if (!au_test_nfs(h_src_sb)) ++ IMustLock(h_src_inode); ++ err = au_clone_or_copy(file[DST].file, file[SRC].file, cpg->len); ++ ++ /* i wonder if we had O_NO_DELAY_FPUT flag */ ++ if (tsk->flags & PF_KTHREAD) ++ __fput_sync(file[DST].file); ++ else { ++ /* it happened actually */ ++ fput(file[DST].file); ++ /* ++ * too bad. ++ * we have to call both since we don't know which place the file ++ * was added to. ++ */ ++ task_work_run(); ++ flush_delayed_fput(); ++ } ++ br = au_sbr(sb, file[DST].bindex); ++ au_lcnt_dec(&br->br_nfiles); ++ ++out_src: ++ fput(file[SRC].file); ++ br = au_sbr(sb, file[SRC].bindex); ++ au_lcnt_dec(&br->br_nfiles); ++out: ++ return err; ++} ++ ++static int au_do_cpup_regular(struct au_cp_generic *cpg, ++ struct au_cpup_reg_attr *h_src_attr) ++{ ++ int err, rerr; ++ loff_t l; ++ struct path h_path; ++ struct inode *h_src_inode, *h_dst_inode; ++ ++ err = 0; ++ h_src_inode = au_h_iptr(d_inode(cpg->dentry), cpg->bsrc); ++ l = i_size_read(h_src_inode); ++ if (cpg->len == -1 || l < cpg->len) ++ cpg->len = l; ++ if (cpg->len) { ++ /* try stopping to update while we are referencing */ ++ inode_lock_shared_nested(h_src_inode, AuLsc_I_CHILD); ++ au_pin_hdir_unlock(cpg->pin); ++ ++ h_path.dentry = au_h_dptr(cpg->dentry, cpg->bsrc); ++ h_path.mnt = au_sbr_mnt(cpg->dentry->d_sb, cpg->bsrc); ++ h_src_attr->iflags = h_src_inode->i_flags; ++ if (!au_test_nfs(h_src_inode->i_sb)) ++ err = vfsub_getattr(&h_path, &h_src_attr->st); ++ else { ++ inode_unlock_shared(h_src_inode); ++ err = vfsub_getattr(&h_path, &h_src_attr->st); ++ inode_lock_shared_nested(h_src_inode, AuLsc_I_CHILD); ++ } ++ if (unlikely(err)) { ++ inode_unlock_shared(h_src_inode); ++ goto out; ++ } ++ h_src_attr->valid = 1; ++ if (!au_test_nfs(h_src_inode->i_sb)) { ++ err = au_cp_regular(cpg); ++ inode_unlock_shared(h_src_inode); ++ } else { ++ inode_unlock_shared(h_src_inode); ++ err = au_cp_regular(cpg); ++ } ++ rerr = au_pin_hdir_relock(cpg->pin); ++ if (!err && rerr) ++ err = rerr; ++ } ++ if (!err && (h_src_inode->i_state & I_LINKABLE)) { ++ h_path.dentry = au_h_dptr(cpg->dentry, cpg->bdst); ++ h_dst_inode = d_inode(h_path.dentry); ++ spin_lock(&h_dst_inode->i_lock); ++ h_dst_inode->i_state |= I_LINKABLE; ++ spin_unlock(&h_dst_inode->i_lock); ++ } ++ ++out: ++ return err; ++} ++ ++static int au_do_cpup_symlink(struct path *h_path, struct dentry *h_src, ++ struct inode *h_dir) ++{ ++ int err, symlen; ++ mm_segment_t old_fs; ++ union { ++ char *k; ++ char __user *u; ++ } sym; ++ ++ err = -ENOMEM; ++ sym.k = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!sym.k)) ++ goto out; ++ ++ /* unnecessary to support mmap_sem since symlink is not mmap-able */ ++ old_fs = get_fs(); ++ set_fs(KERNEL_DS); ++ symlen = vfs_readlink(h_src, sym.u, PATH_MAX); ++ err = symlen; ++ set_fs(old_fs); ++ ++ if (symlen > 0) { ++ sym.k[symlen] = 0; ++ err = vfsub_symlink(h_dir, h_path, sym.k); ++ } ++ free_page((unsigned long)sym.k); ++ ++out: ++ return err; ++} ++ ++/* ++ * regardless 'acl' option, reset all ACL. ++ * All ACL will be copied up later from the original entry on the lower branch. ++ */ ++static int au_reset_acl(struct inode *h_dir, struct path *h_path, umode_t mode) ++{ ++ int err; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ ++ h_dentry = h_path->dentry; ++ h_inode = d_inode(h_dentry); ++ /* forget_all_cached_acls(h_inode)); */ ++ err = vfsub_removexattr(h_dentry, XATTR_NAME_POSIX_ACL_ACCESS); ++ AuTraceErr(err); ++ if (err == -EOPNOTSUPP) ++ err = 0; ++ if (!err) ++ err = vfsub_acl_chmod(h_inode, mode); ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_do_cpup_dir(struct au_cp_generic *cpg, struct dentry *dst_parent, ++ struct inode *h_dir, struct path *h_path) ++{ ++ int err; ++ struct inode *dir, *inode; ++ ++ err = vfsub_removexattr(h_path->dentry, XATTR_NAME_POSIX_ACL_DEFAULT); ++ AuTraceErr(err); ++ if (err == -EOPNOTSUPP) ++ err = 0; ++ if (unlikely(err)) ++ goto out; ++ ++ /* ++ * strange behaviour from the users view, ++ * particularly setattr case ++ */ ++ dir = d_inode(dst_parent); ++ if (au_ibtop(dir) == cpg->bdst) ++ au_cpup_attr_nlink(dir, /*force*/1); ++ inode = d_inode(cpg->dentry); ++ au_cpup_attr_nlink(inode, /*force*/1); ++ ++out: ++ return err; ++} ++ ++static noinline_for_stack ++int cpup_entry(struct au_cp_generic *cpg, struct dentry *dst_parent, ++ struct au_cpup_reg_attr *h_src_attr) ++{ ++ int err; ++ umode_t mode; ++ unsigned int mnt_flags; ++ unsigned char isdir, isreg, force; ++ const unsigned char do_dt = !!au_ftest_cpup(cpg->flags, DTIME); ++ struct au_dtime dt; ++ struct path h_path; ++ struct dentry *h_src, *h_dst, *h_parent; ++ struct inode *h_inode, *h_dir; ++ struct super_block *sb; ++ ++ /* bsrc branch can be ro/rw. */ ++ h_src = au_h_dptr(cpg->dentry, cpg->bsrc); ++ h_inode = d_inode(h_src); ++ AuDebugOn(h_inode != au_h_iptr(d_inode(cpg->dentry), cpg->bsrc)); ++ ++ /* try stopping to be referenced while we are creating */ ++ h_dst = au_h_dptr(cpg->dentry, cpg->bdst); ++ if (au_ftest_cpup(cpg->flags, RENAME)) ++ AuDebugOn(strncmp(h_dst->d_name.name, AUFS_WH_PFX, ++ AUFS_WH_PFX_LEN)); ++ h_parent = h_dst->d_parent; /* dir inode is locked */ ++ h_dir = d_inode(h_parent); ++ IMustLock(h_dir); ++ AuDebugOn(h_parent != h_dst->d_parent); ++ ++ sb = cpg->dentry->d_sb; ++ h_path.mnt = au_sbr_mnt(sb, cpg->bdst); ++ if (do_dt) { ++ h_path.dentry = h_parent; ++ au_dtime_store(&dt, dst_parent, &h_path); ++ } ++ h_path.dentry = h_dst; ++ ++ isreg = 0; ++ isdir = 0; ++ mode = h_inode->i_mode; ++ switch (mode & S_IFMT) { ++ case S_IFREG: ++ isreg = 1; ++ err = vfsub_create(h_dir, &h_path, 0600, /*want_excl*/true); ++ if (!err) ++ err = au_do_cpup_regular(cpg, h_src_attr); ++ break; ++ case S_IFDIR: ++ isdir = 1; ++ err = vfsub_mkdir(h_dir, &h_path, mode); ++ if (!err) ++ err = au_do_cpup_dir(cpg, dst_parent, h_dir, &h_path); ++ break; ++ case S_IFLNK: ++ err = au_do_cpup_symlink(&h_path, h_src, h_dir); ++ break; ++ case S_IFCHR: ++ case S_IFBLK: ++ AuDebugOn(!capable(CAP_MKNOD)); ++ /*FALLTHROUGH*/ ++ case S_IFIFO: ++ case S_IFSOCK: ++ err = vfsub_mknod(h_dir, &h_path, mode, h_inode->i_rdev); ++ break; ++ default: ++ AuIOErr("Unknown inode type 0%o\n", mode); ++ err = -EIO; ++ } ++ if (!err) ++ err = au_reset_acl(h_dir, &h_path, mode); ++ ++ mnt_flags = au_mntflags(sb); ++ if (!au_opt_test(mnt_flags, UDBA_NONE) ++ && !isdir ++ && au_opt_test(mnt_flags, XINO) ++ && (h_inode->i_nlink == 1 ++ || (h_inode->i_state & I_LINKABLE)) ++ /* todo: unnecessary? */ ++ /* && d_inode(cpg->dentry)->i_nlink == 1 */ ++ && cpg->bdst < cpg->bsrc ++ && !au_ftest_cpup(cpg->flags, KEEPLINO)) ++ au_xino_write(sb, cpg->bsrc, h_inode->i_ino, /*ino*/0); ++ /* ignore this error */ ++ ++ if (!err) { ++ force = 0; ++ if (isreg) { ++ force = !!cpg->len; ++ if (cpg->len == -1) ++ force = !!i_size_read(h_inode); ++ } ++ au_fhsm_wrote(sb, cpg->bdst, force); ++ } ++ ++ if (do_dt) ++ au_dtime_revert(&dt); ++ return err; ++} ++ ++static int au_do_ren_after_cpup(struct au_cp_generic *cpg, struct path *h_path) ++{ ++ int err; ++ struct dentry *dentry, *h_dentry, *h_parent, *parent; ++ struct inode *h_dir; ++ aufs_bindex_t bdst; ++ ++ dentry = cpg->dentry; ++ bdst = cpg->bdst; ++ h_dentry = au_h_dptr(dentry, bdst); ++ if (!au_ftest_cpup(cpg->flags, OVERWRITE)) { ++ dget(h_dentry); ++ au_set_h_dptr(dentry, bdst, NULL); ++ err = au_lkup_neg(dentry, bdst, /*wh*/0); ++ if (!err) ++ h_path->dentry = dget(au_h_dptr(dentry, bdst)); ++ au_set_h_dptr(dentry, bdst, h_dentry); ++ } else { ++ err = 0; ++ parent = dget_parent(dentry); ++ h_parent = au_h_dptr(parent, bdst); ++ dput(parent); ++ h_path->dentry = vfsub_lkup_one(&dentry->d_name, h_parent); ++ if (IS_ERR(h_path->dentry)) ++ err = PTR_ERR(h_path->dentry); ++ } ++ if (unlikely(err)) ++ goto out; ++ ++ h_parent = h_dentry->d_parent; /* dir inode is locked */ ++ h_dir = d_inode(h_parent); ++ IMustLock(h_dir); ++ AuDbg("%pd %pd\n", h_dentry, h_path->dentry); ++ /* no delegation since it is just created */ ++ err = vfsub_rename(h_dir, h_dentry, h_dir, h_path, /*delegated*/NULL, ++ /*flags*/0); ++ dput(h_path->dentry); ++ ++out: ++ return err; ++} ++ ++/* ++ * copyup the @dentry from @bsrc to @bdst. ++ * the caller must set the both of lower dentries. ++ * @len is for truncating when it is -1 copyup the entire file. ++ * in link/rename cases, @dst_parent may be different from the real one. ++ * basic->bsrc can be larger than basic->bdst. ++ * aufs doesn't touch the credential so ++ * security_inode_copy_up{,_xattr}() are unnecessary. ++ */ ++static int au_cpup_single(struct au_cp_generic *cpg, struct dentry *dst_parent) ++{ ++ int err, rerr; ++ aufs_bindex_t old_ibtop; ++ unsigned char isdir, plink; ++ struct dentry *h_src, *h_dst, *h_parent; ++ struct inode *dst_inode, *h_dir, *inode, *delegated, *src_inode; ++ struct super_block *sb; ++ struct au_branch *br; ++ /* to reduce stack size */ ++ struct { ++ struct au_dtime dt; ++ struct path h_path; ++ struct au_cpup_reg_attr h_src_attr; ++ } *a; ++ ++ err = -ENOMEM; ++ a = kmalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ a->h_src_attr.valid = 0; ++ ++ sb = cpg->dentry->d_sb; ++ br = au_sbr(sb, cpg->bdst); ++ a->h_path.mnt = au_br_mnt(br); ++ h_dst = au_h_dptr(cpg->dentry, cpg->bdst); ++ h_parent = h_dst->d_parent; /* dir inode is locked */ ++ h_dir = d_inode(h_parent); ++ IMustLock(h_dir); ++ ++ h_src = au_h_dptr(cpg->dentry, cpg->bsrc); ++ inode = d_inode(cpg->dentry); ++ ++ if (!dst_parent) ++ dst_parent = dget_parent(cpg->dentry); ++ else ++ dget(dst_parent); ++ ++ plink = !!au_opt_test(au_mntflags(sb), PLINK); ++ dst_inode = au_h_iptr(inode, cpg->bdst); ++ if (dst_inode) { ++ if (unlikely(!plink)) { ++ err = -EIO; ++ AuIOErr("hi%lu(i%lu) exists on b%d " ++ "but plink is disabled\n", ++ dst_inode->i_ino, inode->i_ino, cpg->bdst); ++ goto out_parent; ++ } ++ ++ if (dst_inode->i_nlink) { ++ const int do_dt = au_ftest_cpup(cpg->flags, DTIME); ++ ++ h_src = au_plink_lkup(inode, cpg->bdst); ++ err = PTR_ERR(h_src); ++ if (IS_ERR(h_src)) ++ goto out_parent; ++ if (unlikely(d_is_negative(h_src))) { ++ err = -EIO; ++ AuIOErr("i%lu exists on b%d " ++ "but not pseudo-linked\n", ++ inode->i_ino, cpg->bdst); ++ dput(h_src); ++ goto out_parent; ++ } ++ ++ if (do_dt) { ++ a->h_path.dentry = h_parent; ++ au_dtime_store(&a->dt, dst_parent, &a->h_path); ++ } ++ ++ a->h_path.dentry = h_dst; ++ delegated = NULL; ++ err = vfsub_link(h_src, h_dir, &a->h_path, &delegated); ++ if (!err && au_ftest_cpup(cpg->flags, RENAME)) ++ err = au_do_ren_after_cpup(cpg, &a->h_path); ++ if (do_dt) ++ au_dtime_revert(&a->dt); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal link\n"); ++ iput(delegated); ++ } ++ dput(h_src); ++ goto out_parent; ++ } else ++ /* todo: cpup_wh_file? */ ++ /* udba work */ ++ au_update_ibrange(inode, /*do_put_zero*/1); ++ } ++ ++ isdir = S_ISDIR(inode->i_mode); ++ old_ibtop = au_ibtop(inode); ++ err = cpup_entry(cpg, dst_parent, &a->h_src_attr); ++ if (unlikely(err)) ++ goto out_rev; ++ dst_inode = d_inode(h_dst); ++ inode_lock_nested(dst_inode, AuLsc_I_CHILD2); ++ /* todo: necessary? */ ++ /* au_pin_hdir_unlock(cpg->pin); */ ++ ++ err = cpup_iattr(cpg->dentry, cpg->bdst, h_src, &a->h_src_attr); ++ if (unlikely(err)) { ++ /* todo: necessary? */ ++ /* au_pin_hdir_relock(cpg->pin); */ /* ignore an error */ ++ inode_unlock(dst_inode); ++ goto out_rev; ++ } ++ ++ if (cpg->bdst < old_ibtop) { ++ if (S_ISREG(inode->i_mode)) { ++ err = au_dy_iaop(inode, cpg->bdst, dst_inode); ++ if (unlikely(err)) { ++ /* ignore an error */ ++ /* au_pin_hdir_relock(cpg->pin); */ ++ inode_unlock(dst_inode); ++ goto out_rev; ++ } ++ } ++ au_set_ibtop(inode, cpg->bdst); ++ } else ++ au_set_ibbot(inode, cpg->bdst); ++ au_set_h_iptr(inode, cpg->bdst, au_igrab(dst_inode), ++ au_hi_flags(inode, isdir)); ++ ++ /* todo: necessary? */ ++ /* err = au_pin_hdir_relock(cpg->pin); */ ++ inode_unlock(dst_inode); ++ if (unlikely(err)) ++ goto out_rev; ++ ++ src_inode = d_inode(h_src); ++ if (!isdir ++ && (src_inode->i_nlink > 1 ++ || src_inode->i_state & I_LINKABLE) ++ && plink) ++ au_plink_append(inode, cpg->bdst, h_dst); ++ ++ if (au_ftest_cpup(cpg->flags, RENAME)) { ++ a->h_path.dentry = h_dst; ++ err = au_do_ren_after_cpup(cpg, &a->h_path); ++ } ++ if (!err) ++ goto out_parent; /* success */ ++ ++ /* revert */ ++out_rev: ++ a->h_path.dentry = h_parent; ++ au_dtime_store(&a->dt, dst_parent, &a->h_path); ++ a->h_path.dentry = h_dst; ++ rerr = 0; ++ if (d_is_positive(h_dst)) { ++ if (!isdir) { ++ /* no delegation since it is just created */ ++ rerr = vfsub_unlink(h_dir, &a->h_path, ++ /*delegated*/NULL, /*force*/0); ++ } else ++ rerr = vfsub_rmdir(h_dir, &a->h_path); ++ } ++ au_dtime_revert(&a->dt); ++ if (rerr) { ++ AuIOErr("failed removing broken entry(%d, %d)\n", err, rerr); ++ err = -EIO; ++ } ++out_parent: ++ dput(dst_parent); ++ au_kfree_rcu(a); ++out: ++ return err; ++} ++ ++#if 0 /* reserved */ ++struct au_cpup_single_args { ++ int *errp; ++ struct au_cp_generic *cpg; ++ struct dentry *dst_parent; ++}; ++ ++static void au_call_cpup_single(void *args) ++{ ++ struct au_cpup_single_args *a = args; ++ ++ au_pin_hdir_acquire_nest(a->cpg->pin); ++ *a->errp = au_cpup_single(a->cpg, a->dst_parent); ++ au_pin_hdir_release(a->cpg->pin); ++} ++#endif ++ ++/* ++ * prevent SIGXFSZ in copy-up. ++ * testing CAP_MKNOD is for generic fs, ++ * but CAP_FSETID is for xfs only, currently. ++ */ ++static int au_cpup_sio_test(struct au_pin *pin, umode_t mode) ++{ ++ int do_sio; ++ struct super_block *sb; ++ struct inode *h_dir; ++ ++ do_sio = 0; ++ sb = au_pinned_parent(pin)->d_sb; ++ if (!au_wkq_test() ++ && (!au_sbi(sb)->si_plink_maint_pid ++ || au_plink_maint(sb, AuLock_NOPLM))) { ++ switch (mode & S_IFMT) { ++ case S_IFREG: ++ /* no condition about RLIMIT_FSIZE and the file size */ ++ do_sio = 1; ++ break; ++ case S_IFCHR: ++ case S_IFBLK: ++ do_sio = !capable(CAP_MKNOD); ++ break; ++ } ++ if (!do_sio) ++ do_sio = ((mode & (S_ISUID | S_ISGID)) ++ && !capable(CAP_FSETID)); ++ /* this workaround may be removed in the future */ ++ if (!do_sio) { ++ h_dir = au_pinned_h_dir(pin); ++ do_sio = h_dir->i_mode & S_ISVTX; ++ } ++ } ++ ++ return do_sio; ++} ++ ++#if 0 /* reserved */ ++int au_sio_cpup_single(struct au_cp_generic *cpg, struct dentry *dst_parent) ++{ ++ int err, wkq_err; ++ struct dentry *h_dentry; ++ ++ h_dentry = au_h_dptr(cpg->dentry, cpg->bsrc); ++ if (!au_cpup_sio_test(pin, d_inode(h_dentry)->i_mode)) ++ err = au_cpup_single(cpg, dst_parent); ++ else { ++ struct au_cpup_single_args args = { ++ .errp = &err, ++ .cpg = cpg, ++ .dst_parent = dst_parent ++ }; ++ wkq_err = au_wkq_wait(au_call_cpup_single, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} ++#endif ++ ++/* ++ * copyup the @dentry from the first active lower branch to @bdst, ++ * using au_cpup_single(). ++ */ ++static int au_cpup_simple(struct au_cp_generic *cpg) ++{ ++ int err; ++ unsigned int flags_orig; ++ struct dentry *dentry; ++ ++ AuDebugOn(cpg->bsrc < 0); ++ ++ dentry = cpg->dentry; ++ DiMustWriteLock(dentry); ++ ++ err = au_lkup_neg(dentry, cpg->bdst, /*wh*/1); ++ if (!err) { ++ flags_orig = cpg->flags; ++ au_fset_cpup(cpg->flags, RENAME); ++ err = au_cpup_single(cpg, NULL); ++ cpg->flags = flags_orig; ++ if (!err) ++ return 0; /* success */ ++ ++ /* revert */ ++ au_set_h_dptr(dentry, cpg->bdst, NULL); ++ au_set_dbtop(dentry, cpg->bsrc); ++ } ++ ++ return err; ++} ++ ++struct au_cpup_simple_args { ++ int *errp; ++ struct au_cp_generic *cpg; ++}; ++ ++static void au_call_cpup_simple(void *args) ++{ ++ struct au_cpup_simple_args *a = args; ++ ++ au_pin_hdir_acquire_nest(a->cpg->pin); ++ *a->errp = au_cpup_simple(a->cpg); ++ au_pin_hdir_release(a->cpg->pin); ++} ++ ++static int au_do_sio_cpup_simple(struct au_cp_generic *cpg) ++{ ++ int err, wkq_err; ++ struct dentry *dentry, *parent; ++ struct file *h_file; ++ struct inode *h_dir; ++ ++ dentry = cpg->dentry; ++ h_file = NULL; ++ if (au_ftest_cpup(cpg->flags, HOPEN)) { ++ AuDebugOn(cpg->bsrc < 0); ++ h_file = au_h_open_pre(dentry, cpg->bsrc, /*force_wr*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ } ++ ++ parent = dget_parent(dentry); ++ h_dir = au_h_iptr(d_inode(parent), cpg->bdst); ++ if (!au_test_h_perm_sio(h_dir, MAY_EXEC | MAY_WRITE) ++ && !au_cpup_sio_test(cpg->pin, d_inode(dentry)->i_mode)) ++ err = au_cpup_simple(cpg); ++ else { ++ struct au_cpup_simple_args args = { ++ .errp = &err, ++ .cpg = cpg ++ }; ++ wkq_err = au_wkq_wait(au_call_cpup_simple, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ dput(parent); ++ if (h_file) ++ au_h_open_post(dentry, cpg->bsrc, h_file); ++ ++out: ++ return err; ++} ++ ++int au_sio_cpup_simple(struct au_cp_generic *cpg) ++{ ++ aufs_bindex_t bsrc, bbot; ++ struct dentry *dentry, *h_dentry; ++ ++ if (cpg->bsrc < 0) { ++ dentry = cpg->dentry; ++ bbot = au_dbbot(dentry); ++ for (bsrc = cpg->bdst + 1; bsrc <= bbot; bsrc++) { ++ h_dentry = au_h_dptr(dentry, bsrc); ++ if (h_dentry) { ++ AuDebugOn(d_is_negative(h_dentry)); ++ break; ++ } ++ } ++ AuDebugOn(bsrc > bbot); ++ cpg->bsrc = bsrc; ++ } ++ AuDebugOn(cpg->bsrc <= cpg->bdst); ++ return au_do_sio_cpup_simple(cpg); ++} ++ ++int au_sio_cpdown_simple(struct au_cp_generic *cpg) ++{ ++ AuDebugOn(cpg->bdst <= cpg->bsrc); ++ return au_do_sio_cpup_simple(cpg); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * copyup the deleted file for writing. ++ */ ++static int au_do_cpup_wh(struct au_cp_generic *cpg, struct dentry *wh_dentry, ++ struct file *file) ++{ ++ int err; ++ unsigned int flags_orig; ++ aufs_bindex_t bsrc_orig; ++ struct au_dinfo *dinfo; ++ struct { ++ struct au_hdentry *hd; ++ struct dentry *h_dentry; ++ } hdst, hsrc; ++ ++ dinfo = au_di(cpg->dentry); ++ AuRwMustWriteLock(&dinfo->di_rwsem); ++ ++ bsrc_orig = cpg->bsrc; ++ cpg->bsrc = dinfo->di_btop; ++ hdst.hd = au_hdentry(dinfo, cpg->bdst); ++ hdst.h_dentry = hdst.hd->hd_dentry; ++ hdst.hd->hd_dentry = wh_dentry; ++ dinfo->di_btop = cpg->bdst; ++ ++ hsrc.h_dentry = NULL; ++ if (file) { ++ hsrc.hd = au_hdentry(dinfo, cpg->bsrc); ++ hsrc.h_dentry = hsrc.hd->hd_dentry; ++ hsrc.hd->hd_dentry = au_hf_top(file)->f_path.dentry; ++ } ++ flags_orig = cpg->flags; ++ cpg->flags = !AuCpup_DTIME; ++ err = au_cpup_single(cpg, /*h_parent*/NULL); ++ cpg->flags = flags_orig; ++ if (file) { ++ if (!err) ++ err = au_reopen_nondir(file); ++ hsrc.hd->hd_dentry = hsrc.h_dentry; ++ } ++ hdst.hd->hd_dentry = hdst.h_dentry; ++ dinfo->di_btop = cpg->bsrc; ++ cpg->bsrc = bsrc_orig; ++ ++ return err; ++} ++ ++static int au_cpup_wh(struct au_cp_generic *cpg, struct file *file) ++{ ++ int err; ++ aufs_bindex_t bdst; ++ struct au_dtime dt; ++ struct dentry *dentry, *parent, *h_parent, *wh_dentry; ++ struct au_branch *br; ++ struct path h_path; ++ ++ dentry = cpg->dentry; ++ bdst = cpg->bdst; ++ br = au_sbr(dentry->d_sb, bdst); ++ parent = dget_parent(dentry); ++ h_parent = au_h_dptr(parent, bdst); ++ wh_dentry = au_whtmp_lkup(h_parent, br, &dentry->d_name); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out; ++ ++ h_path.dentry = h_parent; ++ h_path.mnt = au_br_mnt(br); ++ au_dtime_store(&dt, parent, &h_path); ++ err = au_do_cpup_wh(cpg, wh_dentry, file); ++ if (unlikely(err)) ++ goto out_wh; ++ ++ dget(wh_dentry); ++ h_path.dentry = wh_dentry; ++ if (!d_is_dir(wh_dentry)) { ++ /* no delegation since it is just created */ ++ err = vfsub_unlink(d_inode(h_parent), &h_path, ++ /*delegated*/NULL, /*force*/0); ++ } else ++ err = vfsub_rmdir(d_inode(h_parent), &h_path); ++ if (unlikely(err)) { ++ AuIOErr("failed remove copied-up tmp file %pd(%d)\n", ++ wh_dentry, err); ++ err = -EIO; ++ } ++ au_dtime_revert(&dt); ++ au_set_hi_wh(d_inode(dentry), bdst, wh_dentry); ++ ++out_wh: ++ dput(wh_dentry); ++out: ++ dput(parent); ++ return err; ++} ++ ++struct au_cpup_wh_args { ++ int *errp; ++ struct au_cp_generic *cpg; ++ struct file *file; ++}; ++ ++static void au_call_cpup_wh(void *args) ++{ ++ struct au_cpup_wh_args *a = args; ++ ++ au_pin_hdir_acquire_nest(a->cpg->pin); ++ *a->errp = au_cpup_wh(a->cpg, a->file); ++ au_pin_hdir_release(a->cpg->pin); ++} ++ ++int au_sio_cpup_wh(struct au_cp_generic *cpg, struct file *file) ++{ ++ int err, wkq_err; ++ aufs_bindex_t bdst; ++ struct dentry *dentry, *parent, *h_orph, *h_parent; ++ struct inode *dir, *h_dir, *h_tmpdir; ++ struct au_wbr *wbr; ++ struct au_pin wh_pin, *pin_orig; ++ ++ dentry = cpg->dentry; ++ bdst = cpg->bdst; ++ parent = dget_parent(dentry); ++ dir = d_inode(parent); ++ h_orph = NULL; ++ h_parent = NULL; ++ h_dir = au_igrab(au_h_iptr(dir, bdst)); ++ h_tmpdir = h_dir; ++ pin_orig = NULL; ++ if (!h_dir->i_nlink) { ++ wbr = au_sbr(dentry->d_sb, bdst)->br_wbr; ++ h_orph = wbr->wbr_orph; ++ ++ h_parent = dget(au_h_dptr(parent, bdst)); ++ au_set_h_dptr(parent, bdst, dget(h_orph)); ++ h_tmpdir = d_inode(h_orph); ++ au_set_h_iptr(dir, bdst, au_igrab(h_tmpdir), /*flags*/0); ++ ++ inode_lock_nested(h_tmpdir, AuLsc_I_PARENT3); ++ /* todo: au_h_open_pre()? */ ++ ++ pin_orig = cpg->pin; ++ au_pin_init(&wh_pin, dentry, bdst, AuLsc_DI_PARENT, ++ AuLsc_I_PARENT3, cpg->pin->udba, AuPin_DI_LOCKED); ++ cpg->pin = &wh_pin; ++ } ++ ++ if (!au_test_h_perm_sio(h_tmpdir, MAY_EXEC | MAY_WRITE) ++ && !au_cpup_sio_test(cpg->pin, d_inode(dentry)->i_mode)) ++ err = au_cpup_wh(cpg, file); ++ else { ++ struct au_cpup_wh_args args = { ++ .errp = &err, ++ .cpg = cpg, ++ .file = file ++ }; ++ wkq_err = au_wkq_wait(au_call_cpup_wh, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ if (h_orph) { ++ inode_unlock(h_tmpdir); ++ /* todo: au_h_open_post()? */ ++ au_set_h_iptr(dir, bdst, au_igrab(h_dir), /*flags*/0); ++ au_set_h_dptr(parent, bdst, h_parent); ++ AuDebugOn(!pin_orig); ++ cpg->pin = pin_orig; ++ } ++ iput(h_dir); ++ dput(parent); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * generic routine for both of copy-up and copy-down. ++ */ ++/* cf. revalidate function in file.c */ ++int au_cp_dirs(struct dentry *dentry, aufs_bindex_t bdst, ++ int (*cp)(struct dentry *dentry, aufs_bindex_t bdst, ++ struct au_pin *pin, ++ struct dentry *h_parent, void *arg), ++ void *arg) ++{ ++ int err; ++ struct au_pin pin; ++ struct dentry *d, *parent, *h_parent, *real_parent, *h_dentry; ++ ++ err = 0; ++ parent = dget_parent(dentry); ++ if (IS_ROOT(parent)) ++ goto out; ++ ++ au_pin_init(&pin, dentry, bdst, AuLsc_DI_PARENT2, AuLsc_I_PARENT2, ++ au_opt_udba(dentry->d_sb), AuPin_MNT_WRITE); ++ ++ /* do not use au_dpage */ ++ real_parent = parent; ++ while (1) { ++ dput(parent); ++ parent = dget_parent(dentry); ++ h_parent = au_h_dptr(parent, bdst); ++ if (h_parent) ++ goto out; /* success */ ++ ++ /* find top dir which is necessary to cpup */ ++ do { ++ d = parent; ++ dput(parent); ++ parent = dget_parent(d); ++ di_read_lock_parent3(parent, !AuLock_IR); ++ h_parent = au_h_dptr(parent, bdst); ++ di_read_unlock(parent, !AuLock_IR); ++ } while (!h_parent); ++ ++ if (d != real_parent) ++ di_write_lock_child3(d); ++ ++ /* somebody else might create while we were sleeping */ ++ h_dentry = au_h_dptr(d, bdst); ++ if (!h_dentry || d_is_negative(h_dentry)) { ++ if (h_dentry) ++ au_update_dbtop(d); ++ ++ au_pin_set_dentry(&pin, d); ++ err = au_do_pin(&pin); ++ if (!err) { ++ err = cp(d, bdst, &pin, h_parent, arg); ++ au_unpin(&pin); ++ } ++ } ++ ++ if (d != real_parent) ++ di_write_unlock(d); ++ if (unlikely(err)) ++ break; ++ } ++ ++out: ++ dput(parent); ++ return err; ++} ++ ++static int au_cpup_dir(struct dentry *dentry, aufs_bindex_t bdst, ++ struct au_pin *pin, ++ struct dentry *h_parent __maybe_unused, ++ void *arg __maybe_unused) ++{ ++ struct au_cp_generic cpg = { ++ .dentry = dentry, ++ .bdst = bdst, ++ .bsrc = -1, ++ .len = 0, ++ .pin = pin, ++ .flags = AuCpup_DTIME ++ }; ++ return au_sio_cpup_simple(&cpg); ++} ++ ++int au_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst) ++{ ++ return au_cp_dirs(dentry, bdst, au_cpup_dir, NULL); ++} ++ ++int au_test_and_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst) ++{ ++ int err; ++ struct dentry *parent; ++ struct inode *dir; ++ ++ parent = dget_parent(dentry); ++ dir = d_inode(parent); ++ err = 0; ++ if (au_h_iptr(dir, bdst)) ++ goto out; ++ ++ di_read_unlock(parent, AuLock_IR); ++ di_write_lock_parent(parent); ++ /* someone else might change our inode while we were sleeping */ ++ if (!au_h_iptr(dir, bdst)) ++ err = au_cpup_dirs(dentry, bdst); ++ di_downgrade_lock(parent, AuLock_IR); ++ ++out: ++ dput(parent); ++ return err; ++} +diff --git a/fs/aufs/cpup.h b/fs/aufs/cpup.h +new file mode 100644 +index 000000000000..c23c1bbcee7e +--- /dev/null ++++ b/fs/aufs/cpup.h +@@ -0,0 +1,87 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * copy-up/down functions ++ */ ++ ++#ifndef __AUFS_CPUP_H__ ++#define __AUFS_CPUP_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++ ++struct inode; ++struct file; ++struct au_pin; ++ ++void au_cpup_attr_flags(struct inode *dst, unsigned int iflags); ++void au_cpup_attr_timesizes(struct inode *inode); ++void au_cpup_attr_nlink(struct inode *inode, int force); ++void au_cpup_attr_changeable(struct inode *inode); ++void au_cpup_igen(struct inode *inode, struct inode *h_inode); ++void au_cpup_attr_all(struct inode *inode, int force); ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_cp_generic { ++ struct dentry *dentry; ++ aufs_bindex_t bdst, bsrc; ++ loff_t len; ++ struct au_pin *pin; ++ unsigned int flags; ++}; ++ ++/* cpup flags */ ++#define AuCpup_DTIME 1 /* do dtime_store/revert */ ++#define AuCpup_KEEPLINO (1 << 1) /* do not clear the lower xino, ++ for link(2) */ ++#define AuCpup_RENAME (1 << 2) /* rename after cpup */ ++#define AuCpup_HOPEN (1 << 3) /* call h_open_pre/post() in ++ cpup */ ++#define AuCpup_OVERWRITE (1 << 4) /* allow overwriting the ++ existing entry */ ++#define AuCpup_RWDST (1 << 5) /* force write target even if ++ the branch is marked as RO */ ++ ++#ifndef CONFIG_AUFS_BR_HFSPLUS ++#undef AuCpup_HOPEN ++#define AuCpup_HOPEN 0 ++#endif ++ ++#define au_ftest_cpup(flags, name) ((flags) & AuCpup_##name) ++#define au_fset_cpup(flags, name) \ ++ do { (flags) |= AuCpup_##name; } while (0) ++#define au_fclr_cpup(flags, name) \ ++ do { (flags) &= ~AuCpup_##name; } while (0) ++ ++int au_copy_file(struct file *dst, struct file *src, loff_t len); ++int au_sio_cpup_simple(struct au_cp_generic *cpg); ++int au_sio_cpdown_simple(struct au_cp_generic *cpg); ++int au_sio_cpup_wh(struct au_cp_generic *cpg, struct file *file); ++ ++int au_cp_dirs(struct dentry *dentry, aufs_bindex_t bdst, ++ int (*cp)(struct dentry *dentry, aufs_bindex_t bdst, ++ struct au_pin *pin, ++ struct dentry *h_parent, void *arg), ++ void *arg); ++int au_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst); ++int au_test_and_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* keep timestamps when copyup */ ++struct au_dtime { ++ struct dentry *dt_dentry; ++ struct path dt_h_path; ++ struct timespec64 dt_atime, dt_mtime; ++}; ++void au_dtime_store(struct au_dtime *dt, struct dentry *dentry, ++ struct path *h_path); ++void au_dtime_revert(struct au_dtime *dt); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_CPUP_H__ */ +diff --git a/fs/aufs/dbgaufs.c b/fs/aufs/dbgaufs.c +new file mode 100644 +index 000000000000..63f40a324f1b +--- /dev/null ++++ b/fs/aufs/dbgaufs.c +@@ -0,0 +1,513 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * debugfs interface ++ */ ++ ++#include ++#include "aufs.h" ++ ++#ifndef CONFIG_SYSFS ++#error DEBUG_FS depends upon SYSFS ++#endif ++ ++static struct dentry *dbgaufs; ++static const mode_t dbgaufs_mode = 0444; ++ ++/* 20 is max digits length of ulong 64 */ ++struct dbgaufs_arg { ++ int n; ++ char a[20 * 4]; ++}; ++ ++/* ++ * common function for all XINO files ++ */ ++static int dbgaufs_xi_release(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ void *p; ++ ++ p = file->private_data; ++ if (p) { ++ /* this is struct dbgaufs_arg */ ++ AuDebugOn(!au_kfree_sz_test(p)); ++ au_kfree_do_rcu(p); ++ } ++ return 0; ++} ++ ++static int dbgaufs_xi_open(struct file *xf, struct file *file, int do_fcnt, ++ int cnt) ++{ ++ int err; ++ struct kstat st; ++ struct dbgaufs_arg *p; ++ ++ err = -ENOMEM; ++ p = kmalloc(sizeof(*p), GFP_NOFS); ++ if (unlikely(!p)) ++ goto out; ++ ++ err = 0; ++ p->n = 0; ++ file->private_data = p; ++ if (!xf) ++ goto out; ++ ++ err = vfsub_getattr(&xf->f_path, &st); ++ if (!err) { ++ if (do_fcnt) ++ p->n = snprintf ++ (p->a, sizeof(p->a), "%d, %llux%u %lld\n", ++ cnt, st.blocks, st.blksize, ++ (long long)st.size); ++ else ++ p->n = snprintf(p->a, sizeof(p->a), "%llux%u %lld\n", ++ st.blocks, st.blksize, ++ (long long)st.size); ++ AuDebugOn(p->n >= sizeof(p->a)); ++ } else { ++ p->n = snprintf(p->a, sizeof(p->a), "err %d\n", err); ++ err = 0; ++ } ++ ++out: ++ return err; ++} ++ ++static ssize_t dbgaufs_xi_read(struct file *file, char __user *buf, ++ size_t count, loff_t *ppos) ++{ ++ struct dbgaufs_arg *p; ++ ++ p = file->private_data; ++ return simple_read_from_buffer(buf, count, ppos, p->a, p->n); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct dbgaufs_plink_arg { ++ int n; ++ char a[]; ++}; ++ ++static int dbgaufs_plink_release(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ free_page((unsigned long)file->private_data); ++ return 0; ++} ++ ++static int dbgaufs_plink_open(struct inode *inode, struct file *file) ++{ ++ int err, i, limit; ++ unsigned long n, sum; ++ struct dbgaufs_plink_arg *p; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ struct hlist_bl_head *hbl; ++ ++ err = -ENOMEM; ++ p = (void *)get_zeroed_page(GFP_NOFS); ++ if (unlikely(!p)) ++ goto out; ++ ++ err = -EFBIG; ++ sbinfo = inode->i_private; ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ if (au_opt_test(au_mntflags(sb), PLINK)) { ++ limit = PAGE_SIZE - sizeof(p->n); ++ ++ /* the number of buckets */ ++ n = snprintf(p->a + p->n, limit, "%d\n", AuPlink_NHASH); ++ p->n += n; ++ limit -= n; ++ ++ sum = 0; ++ for (i = 0, hbl = sbinfo->si_plink; i < AuPlink_NHASH; ++ i++, hbl++) { ++ n = au_hbl_count(hbl); ++ sum += n; ++ ++ n = snprintf(p->a + p->n, limit, "%lu ", n); ++ p->n += n; ++ limit -= n; ++ if (unlikely(limit <= 0)) ++ goto out_free; ++ } ++ p->a[p->n - 1] = '\n'; ++ ++ /* the sum of plinks */ ++ n = snprintf(p->a + p->n, limit, "%lu\n", sum); ++ p->n += n; ++ limit -= n; ++ if (unlikely(limit <= 0)) ++ goto out_free; ++ } else { ++#define str "1\n0\n0\n" ++ p->n = sizeof(str) - 1; ++ strcpy(p->a, str); ++#undef str ++ } ++ si_read_unlock(sb); ++ ++ err = 0; ++ file->private_data = p; ++ goto out; /* success */ ++ ++out_free: ++ free_page((unsigned long)p); ++out: ++ return err; ++} ++ ++static ssize_t dbgaufs_plink_read(struct file *file, char __user *buf, ++ size_t count, loff_t *ppos) ++{ ++ struct dbgaufs_plink_arg *p; ++ ++ p = file->private_data; ++ return simple_read_from_buffer(buf, count, ppos, p->a, p->n); ++} ++ ++static const struct file_operations dbgaufs_plink_fop = { ++ .owner = THIS_MODULE, ++ .open = dbgaufs_plink_open, ++ .release = dbgaufs_plink_release, ++ .read = dbgaufs_plink_read ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int dbgaufs_xib_open(struct inode *inode, struct file *file) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ ++ sbinfo = inode->i_private; ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ err = dbgaufs_xi_open(sbinfo->si_xib, file, /*do_fcnt*/0, /*cnt*/0); ++ si_read_unlock(sb); ++ return err; ++} ++ ++static const struct file_operations dbgaufs_xib_fop = { ++ .owner = THIS_MODULE, ++ .open = dbgaufs_xib_open, ++ .release = dbgaufs_xi_release, ++ .read = dbgaufs_xi_read ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define DbgaufsXi_PREFIX "xi" ++ ++static int dbgaufs_xino_open(struct inode *inode, struct file *file) ++{ ++ int err, idx; ++ long l; ++ aufs_bindex_t bindex; ++ char *p, a[sizeof(DbgaufsXi_PREFIX) + 8]; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ struct au_xino *xi; ++ struct file *xf; ++ struct qstr *name; ++ struct au_branch *br; ++ ++ err = -ENOENT; ++ name = &file->f_path.dentry->d_name; ++ if (unlikely(name->len < sizeof(DbgaufsXi_PREFIX) ++ || memcmp(name->name, DbgaufsXi_PREFIX, ++ sizeof(DbgaufsXi_PREFIX) - 1))) ++ goto out; ++ ++ AuDebugOn(name->len >= sizeof(a)); ++ memcpy(a, name->name, name->len); ++ a[name->len] = '\0'; ++ p = strchr(a, '-'); ++ if (p) ++ *p = '\0'; ++ err = kstrtol(a + sizeof(DbgaufsXi_PREFIX) - 1, 10, &l); ++ if (unlikely(err)) ++ goto out; ++ bindex = l; ++ idx = 0; ++ if (p) { ++ err = kstrtol(p + 1, 10, &l); ++ if (unlikely(err)) ++ goto out; ++ idx = l; ++ } ++ ++ err = -ENOENT; ++ sbinfo = inode->i_private; ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ if (unlikely(bindex < 0 || bindex > au_sbbot(sb))) ++ goto out_si; ++ br = au_sbr(sb, bindex); ++ xi = br->br_xino; ++ if (unlikely(idx >= xi->xi_nfile)) ++ goto out_si; ++ xf = au_xino_file(xi, idx); ++ if (xf) ++ err = dbgaufs_xi_open(xf, file, /*do_fcnt*/1, ++ au_xino_count(br)); ++ ++out_si: ++ si_read_unlock(sb); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static const struct file_operations dbgaufs_xino_fop = { ++ .owner = THIS_MODULE, ++ .open = dbgaufs_xino_open, ++ .release = dbgaufs_xi_release, ++ .read = dbgaufs_xi_read ++}; ++ ++void dbgaufs_xino_del(struct au_branch *br) ++{ ++ struct dentry *dbgaufs; ++ ++ dbgaufs = br->br_dbgaufs; ++ if (!dbgaufs) ++ return; ++ ++ br->br_dbgaufs = NULL; ++ /* debugfs acquires the parent i_mutex */ ++ lockdep_off(); ++ debugfs_remove(dbgaufs); ++ lockdep_on(); ++} ++ ++void dbgaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ aufs_bindex_t bbot; ++ struct au_branch *br; ++ ++ if (!au_sbi(sb)->si_dbgaufs) ++ return; ++ ++ bbot = au_sbbot(sb); ++ for (; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ dbgaufs_xino_del(br); ++ } ++} ++ ++static void dbgaufs_br_do_add(struct super_block *sb, aufs_bindex_t bindex, ++ unsigned int idx, struct dentry *parent, ++ struct au_sbinfo *sbinfo) ++{ ++ struct au_branch *br; ++ struct dentry *d; ++ /* "xi" bindex(5) "-" idx(2) NULL */ ++ char name[sizeof(DbgaufsXi_PREFIX) + 8]; ++ ++ if (!idx) ++ snprintf(name, sizeof(name), DbgaufsXi_PREFIX "%d", bindex); ++ else ++ snprintf(name, sizeof(name), DbgaufsXi_PREFIX "%d-%u", ++ bindex, idx); ++ br = au_sbr(sb, bindex); ++ if (br->br_dbgaufs) { ++ struct qstr qstr = QSTR_INIT(name, strlen(name)); ++ ++ if (!au_qstreq(&br->br_dbgaufs->d_name, &qstr)) { ++ /* debugfs acquires the parent i_mutex */ ++ lockdep_off(); ++ d = debugfs_rename(parent, br->br_dbgaufs, parent, ++ name); ++ lockdep_on(); ++ if (unlikely(!d)) ++ pr_warn("failed renaming %pd/%s, ignored.\n", ++ parent, name); ++ } ++ } else { ++ lockdep_off(); ++ br->br_dbgaufs = debugfs_create_file(name, dbgaufs_mode, parent, ++ sbinfo, &dbgaufs_xino_fop); ++ lockdep_on(); ++ if (unlikely(!br->br_dbgaufs)) ++ pr_warn("failed creating %pd/%s, ignored.\n", ++ parent, name); ++ } ++} ++ ++static void dbgaufs_br_add(struct super_block *sb, aufs_bindex_t bindex, ++ struct dentry *parent, struct au_sbinfo *sbinfo) ++{ ++ struct au_branch *br; ++ struct au_xino *xi; ++ unsigned int u; ++ ++ br = au_sbr(sb, bindex); ++ xi = br->br_xino; ++ for (u = 0; u < xi->xi_nfile; u++) ++ dbgaufs_br_do_add(sb, bindex, u, parent, sbinfo); ++} ++ ++void dbgaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex, int topdown) ++{ ++ struct au_sbinfo *sbinfo; ++ struct dentry *parent; ++ aufs_bindex_t bbot; ++ ++ if (!au_opt_test(au_mntflags(sb), XINO)) ++ return; ++ ++ sbinfo = au_sbi(sb); ++ parent = sbinfo->si_dbgaufs; ++ if (!parent) ++ return; ++ ++ bbot = au_sbbot(sb); ++ if (topdown) ++ for (; bindex <= bbot; bindex++) ++ dbgaufs_br_add(sb, bindex, parent, sbinfo); ++ else ++ for (; bbot >= bindex; bbot--) ++ dbgaufs_br_add(sb, bbot, parent, sbinfo); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_EXPORT ++static int dbgaufs_xigen_open(struct inode *inode, struct file *file) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ ++ sbinfo = inode->i_private; ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ err = dbgaufs_xi_open(sbinfo->si_xigen, file, /*do_fcnt*/0, /*cnt*/0); ++ si_read_unlock(sb); ++ return err; ++} ++ ++static const struct file_operations dbgaufs_xigen_fop = { ++ .owner = THIS_MODULE, ++ .open = dbgaufs_xigen_open, ++ .release = dbgaufs_xi_release, ++ .read = dbgaufs_xi_read ++}; ++ ++static int dbgaufs_xigen_init(struct au_sbinfo *sbinfo) ++{ ++ int err; ++ ++ /* ++ * This function is a dynamic '__init' function actually, ++ * so the tiny check for si_rwsem is unnecessary. ++ */ ++ /* AuRwMustWriteLock(&sbinfo->si_rwsem); */ ++ ++ err = -EIO; ++ sbinfo->si_dbgaufs_xigen = debugfs_create_file ++ ("xigen", dbgaufs_mode, sbinfo->si_dbgaufs, sbinfo, ++ &dbgaufs_xigen_fop); ++ if (sbinfo->si_dbgaufs_xigen) ++ err = 0; ++ ++ return err; ++} ++#else ++static int dbgaufs_xigen_init(struct au_sbinfo *sbinfo) ++{ ++ return 0; ++} ++#endif /* CONFIG_AUFS_EXPORT */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++void dbgaufs_si_fin(struct au_sbinfo *sbinfo) ++{ ++ /* ++ * This function is a dynamic '__fin' function actually, ++ * so the tiny check for si_rwsem is unnecessary. ++ */ ++ /* AuRwMustWriteLock(&sbinfo->si_rwsem); */ ++ ++ debugfs_remove_recursive(sbinfo->si_dbgaufs); ++ sbinfo->si_dbgaufs = NULL; ++} ++ ++int dbgaufs_si_init(struct au_sbinfo *sbinfo) ++{ ++ int err; ++ char name[SysaufsSiNameLen]; ++ ++ /* ++ * This function is a dynamic '__init' function actually, ++ * so the tiny check for si_rwsem is unnecessary. ++ */ ++ /* AuRwMustWriteLock(&sbinfo->si_rwsem); */ ++ ++ err = -ENOENT; ++ if (!dbgaufs) { ++ AuErr1("/debug/aufs is uninitialized\n"); ++ goto out; ++ } ++ ++ err = -EIO; ++ sysaufs_name(sbinfo, name); ++ sbinfo->si_dbgaufs = debugfs_create_dir(name, dbgaufs); ++ if (unlikely(!sbinfo->si_dbgaufs)) ++ goto out; ++ ++ /* regardless plink/noplink option */ ++ sbinfo->si_dbgaufs_plink = debugfs_create_file ++ ("plink", dbgaufs_mode, sbinfo->si_dbgaufs, sbinfo, ++ &dbgaufs_plink_fop); ++ if (unlikely(!sbinfo->si_dbgaufs_plink)) ++ goto out_dir; ++ ++ /* regardless xino/noxino option */ ++ sbinfo->si_dbgaufs_xib = debugfs_create_file ++ ("xib", dbgaufs_mode, sbinfo->si_dbgaufs, sbinfo, ++ &dbgaufs_xib_fop); ++ if (unlikely(!sbinfo->si_dbgaufs_xib)) ++ goto out_dir; ++ ++ err = dbgaufs_xigen_init(sbinfo); ++ if (!err) ++ goto out; /* success */ ++ ++out_dir: ++ dbgaufs_si_fin(sbinfo); ++out: ++ if (unlikely(err)) ++ pr_err("debugfs/aufs failed\n"); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void dbgaufs_fin(void) ++{ ++ debugfs_remove(dbgaufs); ++} ++ ++int __init dbgaufs_init(void) ++{ ++ int err; ++ ++ err = -EIO; ++ dbgaufs = debugfs_create_dir(AUFS_NAME, NULL); ++ if (dbgaufs) ++ err = 0; ++ return err; ++} +diff --git a/fs/aufs/dbgaufs.h b/fs/aufs/dbgaufs.h +new file mode 100644 +index 000000000000..ad26624a9345 +--- /dev/null ++++ b/fs/aufs/dbgaufs.h +@@ -0,0 +1,40 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * debugfs interface ++ */ ++ ++#ifndef __DBGAUFS_H__ ++#define __DBGAUFS_H__ ++ ++#ifdef __KERNEL__ ++ ++struct super_block; ++struct au_sbinfo; ++struct au_branch; ++ ++#ifdef CONFIG_DEBUG_FS ++/* dbgaufs.c */ ++void dbgaufs_xino_del(struct au_branch *br); ++void dbgaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex); ++void dbgaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex, int topdown); ++void dbgaufs_si_fin(struct au_sbinfo *sbinfo); ++int dbgaufs_si_init(struct au_sbinfo *sbinfo); ++void dbgaufs_fin(void); ++int __init dbgaufs_init(void); ++#else ++AuStubVoid(dbgaufs_xino_del, struct au_branch *br) ++AuStubVoid(dbgaufs_brs_del, struct super_block *sb, aufs_bindex_t bindex) ++AuStubVoid(dbgaufs_brs_add, struct super_block *sb, aufs_bindex_t bindex, ++ int topdown) ++AuStubVoid(dbgaufs_si_fin, struct au_sbinfo *sbinfo) ++AuStubInt0(dbgaufs_si_init, struct au_sbinfo *sbinfo) ++AuStubVoid(dbgaufs_fin, void) ++AuStubInt0(__init dbgaufs_init, void) ++#endif /* CONFIG_DEBUG_FS */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __DBGAUFS_H__ */ +diff --git a/fs/aufs/dcsub.c b/fs/aufs/dcsub.c +new file mode 100644 +index 000000000000..000854da9075 +--- /dev/null ++++ b/fs/aufs/dcsub.c +@@ -0,0 +1,212 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * sub-routines for dentry cache ++ */ ++ ++#include "aufs.h" ++ ++static void au_dpage_free(struct au_dpage *dpage) ++{ ++ int i; ++ struct dentry **p; ++ ++ p = dpage->dentries; ++ for (i = 0; i < dpage->ndentry; i++) ++ dput(*p++); ++ free_page((unsigned long)dpage->dentries); ++} ++ ++int au_dpages_init(struct au_dcsub_pages *dpages, gfp_t gfp) ++{ ++ int err; ++ void *p; ++ ++ err = -ENOMEM; ++ dpages->dpages = kmalloc(sizeof(*dpages->dpages), gfp); ++ if (unlikely(!dpages->dpages)) ++ goto out; ++ ++ p = (void *)__get_free_page(gfp); ++ if (unlikely(!p)) ++ goto out_dpages; ++ ++ dpages->dpages[0].ndentry = 0; ++ dpages->dpages[0].dentries = p; ++ dpages->ndpage = 1; ++ return 0; /* success */ ++ ++out_dpages: ++ au_kfree_try_rcu(dpages->dpages); ++out: ++ return err; ++} ++ ++void au_dpages_free(struct au_dcsub_pages *dpages) ++{ ++ int i; ++ struct au_dpage *p; ++ ++ p = dpages->dpages; ++ for (i = 0; i < dpages->ndpage; i++) ++ au_dpage_free(p++); ++ au_kfree_try_rcu(dpages->dpages); ++} ++ ++static int au_dpages_append(struct au_dcsub_pages *dpages, ++ struct dentry *dentry, gfp_t gfp) ++{ ++ int err, sz; ++ struct au_dpage *dpage; ++ void *p; ++ ++ dpage = dpages->dpages + dpages->ndpage - 1; ++ sz = PAGE_SIZE / sizeof(dentry); ++ if (unlikely(dpage->ndentry >= sz)) { ++ AuLabel(new dpage); ++ err = -ENOMEM; ++ sz = dpages->ndpage * sizeof(*dpages->dpages); ++ p = au_kzrealloc(dpages->dpages, sz, ++ sz + sizeof(*dpages->dpages), gfp, ++ /*may_shrink*/0); ++ if (unlikely(!p)) ++ goto out; ++ ++ dpages->dpages = p; ++ dpage = dpages->dpages + dpages->ndpage; ++ p = (void *)__get_free_page(gfp); ++ if (unlikely(!p)) ++ goto out; ++ ++ dpage->ndentry = 0; ++ dpage->dentries = p; ++ dpages->ndpage++; ++ } ++ ++ AuDebugOn(au_dcount(dentry) <= 0); ++ dpage->dentries[dpage->ndentry++] = dget_dlock(dentry); ++ return 0; /* success */ ++ ++out: ++ return err; ++} ++ ++/* todo: BAD approach */ ++/* copied from linux/fs/dcache.c */ ++enum d_walk_ret { ++ D_WALK_CONTINUE, ++ D_WALK_QUIT, ++ D_WALK_NORETRY, ++ D_WALK_SKIP, ++}; ++ ++extern void d_walk(struct dentry *parent, void *data, ++ enum d_walk_ret (*enter)(void *, struct dentry *)); ++ ++struct ac_dpages_arg { ++ int err; ++ struct au_dcsub_pages *dpages; ++ struct super_block *sb; ++ au_dpages_test test; ++ void *arg; ++}; ++ ++static enum d_walk_ret au_call_dpages_append(void *_arg, struct dentry *dentry) ++{ ++ enum d_walk_ret ret; ++ struct ac_dpages_arg *arg = _arg; ++ ++ ret = D_WALK_CONTINUE; ++ if (dentry->d_sb == arg->sb ++ && !IS_ROOT(dentry) ++ && au_dcount(dentry) > 0 ++ && au_di(dentry) ++ && (!arg->test || arg->test(dentry, arg->arg))) { ++ arg->err = au_dpages_append(arg->dpages, dentry, GFP_ATOMIC); ++ if (unlikely(arg->err)) ++ ret = D_WALK_QUIT; ++ } ++ ++ return ret; ++} ++ ++int au_dcsub_pages(struct au_dcsub_pages *dpages, struct dentry *root, ++ au_dpages_test test, void *arg) ++{ ++ struct ac_dpages_arg args = { ++ .err = 0, ++ .dpages = dpages, ++ .sb = root->d_sb, ++ .test = test, ++ .arg = arg ++ }; ++ ++ d_walk(root, &args, au_call_dpages_append); ++ ++ return args.err; ++} ++ ++int au_dcsub_pages_rev(struct au_dcsub_pages *dpages, struct dentry *dentry, ++ int do_include, au_dpages_test test, void *arg) ++{ ++ int err; ++ ++ err = 0; ++ write_seqlock(&rename_lock); ++ spin_lock(&dentry->d_lock); ++ if (do_include ++ && au_dcount(dentry) > 0 ++ && (!test || test(dentry, arg))) ++ err = au_dpages_append(dpages, dentry, GFP_ATOMIC); ++ spin_unlock(&dentry->d_lock); ++ if (unlikely(err)) ++ goto out; ++ ++ /* ++ * RCU for vfsmount is unnecessary since this is a traverse in a single ++ * mount ++ */ ++ while (!IS_ROOT(dentry)) { ++ dentry = dentry->d_parent; /* rename_lock is locked */ ++ spin_lock(&dentry->d_lock); ++ if (au_dcount(dentry) > 0 ++ && (!test || test(dentry, arg))) ++ err = au_dpages_append(dpages, dentry, GFP_ATOMIC); ++ spin_unlock(&dentry->d_lock); ++ if (unlikely(err)) ++ break; ++ } ++ ++out: ++ write_sequnlock(&rename_lock); ++ return err; ++} ++ ++static inline int au_dcsub_dpages_aufs(struct dentry *dentry, void *arg) ++{ ++ return au_di(dentry) && dentry->d_sb == arg; ++} ++ ++int au_dcsub_pages_rev_aufs(struct au_dcsub_pages *dpages, ++ struct dentry *dentry, int do_include) ++{ ++ return au_dcsub_pages_rev(dpages, dentry, do_include, ++ au_dcsub_dpages_aufs, dentry->d_sb); ++} ++ ++int au_test_subdir(struct dentry *d1, struct dentry *d2) ++{ ++ struct path path[2] = { ++ { ++ .dentry = d1 ++ }, ++ { ++ .dentry = d2 ++ } ++ }; ++ ++ return path_is_under(path + 0, path + 1); ++} +diff --git a/fs/aufs/dcsub.h b/fs/aufs/dcsub.h +new file mode 100644 +index 000000000000..9d207c2b4666 +--- /dev/null ++++ b/fs/aufs/dcsub.h +@@ -0,0 +1,124 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * sub-routines for dentry cache ++ */ ++ ++#ifndef __AUFS_DCSUB_H__ ++#define __AUFS_DCSUB_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++ ++struct au_dpage { ++ int ndentry; ++ struct dentry **dentries; ++}; ++ ++struct au_dcsub_pages { ++ int ndpage; ++ struct au_dpage *dpages; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dcsub.c */ ++int au_dpages_init(struct au_dcsub_pages *dpages, gfp_t gfp); ++void au_dpages_free(struct au_dcsub_pages *dpages); ++typedef int (*au_dpages_test)(struct dentry *dentry, void *arg); ++int au_dcsub_pages(struct au_dcsub_pages *dpages, struct dentry *root, ++ au_dpages_test test, void *arg); ++int au_dcsub_pages_rev(struct au_dcsub_pages *dpages, struct dentry *dentry, ++ int do_include, au_dpages_test test, void *arg); ++int au_dcsub_pages_rev_aufs(struct au_dcsub_pages *dpages, ++ struct dentry *dentry, int do_include); ++int au_test_subdir(struct dentry *d1, struct dentry *d2); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * todo: in linux-3.13, several similar (but faster) helpers are added to ++ * include/linux/dcache.h. Try them (in the future). ++ */ ++ ++static inline int au_d_hashed_positive(struct dentry *d) ++{ ++ int err; ++ struct inode *inode = d_inode(d); ++ ++ err = 0; ++ if (unlikely(d_unhashed(d) ++ || d_is_negative(d) ++ || !inode->i_nlink)) ++ err = -ENOENT; ++ return err; ++} ++ ++static inline int au_d_linkable(struct dentry *d) ++{ ++ int err; ++ struct inode *inode = d_inode(d); ++ ++ err = au_d_hashed_positive(d); ++ if (err ++ && d_is_positive(d) ++ && (inode->i_state & I_LINKABLE)) ++ err = 0; ++ return err; ++} ++ ++static inline int au_d_alive(struct dentry *d) ++{ ++ int err; ++ struct inode *inode; ++ ++ err = 0; ++ if (!IS_ROOT(d)) ++ err = au_d_hashed_positive(d); ++ else { ++ inode = d_inode(d); ++ if (unlikely(d_unlinked(d) ++ || d_is_negative(d) ++ || !inode->i_nlink)) ++ err = -ENOENT; ++ } ++ return err; ++} ++ ++static inline int au_alive_dir(struct dentry *d) ++{ ++ int err; ++ ++ err = au_d_alive(d); ++ if (unlikely(err || IS_DEADDIR(d_inode(d)))) ++ err = -ENOENT; ++ return err; ++} ++ ++static inline int au_qstreq(struct qstr *a, struct qstr *b) ++{ ++ return a->len == b->len ++ && !memcmp(a->name, b->name, a->len); ++} ++ ++/* ++ * by the commit ++ * 360f547 2015-01-25 dcache: let the dentry count go down to zero without ++ * taking d_lock ++ * the type of d_lockref.count became int, but the inlined function d_count() ++ * still returns unsigned int. ++ * I don't know why. Maybe it is for every d_count() users? ++ * Anyway au_dcount() lives on. ++ */ ++static inline int au_dcount(struct dentry *d) ++{ ++ return (int)d_count(d); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DCSUB_H__ */ +diff --git a/fs/aufs/debug.c b/fs/aufs/debug.c +new file mode 100644 +index 000000000000..fd0ba9d15742 +--- /dev/null ++++ b/fs/aufs/debug.c +@@ -0,0 +1,428 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * debug print functions ++ */ ++ ++#include ++#include "aufs.h" ++ ++/* Returns 0, or -errno. arg is in kp->arg. */ ++static int param_atomic_t_set(const char *val, const struct kernel_param *kp) ++{ ++ int err, n; ++ ++ err = kstrtoint(val, 0, &n); ++ if (!err) { ++ if (n > 0) ++ au_debug_on(); ++ else ++ au_debug_off(); ++ } ++ return err; ++} ++ ++/* Returns length written or -errno. Buffer is 4k (ie. be short!) */ ++static int param_atomic_t_get(char *buffer, const struct kernel_param *kp) ++{ ++ atomic_t *a; ++ ++ a = kp->arg; ++ return sprintf(buffer, "%d", atomic_read(a)); ++} ++ ++static struct kernel_param_ops param_ops_atomic_t = { ++ .set = param_atomic_t_set, ++ .get = param_atomic_t_get ++ /* void (*free)(void *arg) */ ++}; ++ ++atomic_t aufs_debug = ATOMIC_INIT(0); ++MODULE_PARM_DESC(debug, "debug print"); ++module_param_named(debug, aufs_debug, atomic_t, 0664); ++ ++DEFINE_MUTEX(au_dbg_mtx); /* just to serialize the dbg msgs */ ++char *au_plevel = KERN_DEBUG; ++#define dpri(fmt, ...) do { \ ++ if ((au_plevel \ ++ && strcmp(au_plevel, KERN_DEBUG)) \ ++ || au_debug_test()) \ ++ printk("%s" fmt, au_plevel, ##__VA_ARGS__); \ ++} while (0) ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_dpri_whlist(struct au_nhash *whlist) ++{ ++ unsigned long ul, n; ++ struct hlist_head *head; ++ struct au_vdir_wh *pos; ++ ++ n = whlist->nh_num; ++ head = whlist->nh_head; ++ for (ul = 0; ul < n; ul++) { ++ hlist_for_each_entry(pos, head, wh_hash) ++ dpri("b%d, %.*s, %d\n", ++ pos->wh_bindex, ++ pos->wh_str.len, pos->wh_str.name, ++ pos->wh_str.len); ++ head++; ++ } ++} ++ ++void au_dpri_vdir(struct au_vdir *vdir) ++{ ++ unsigned long ul; ++ union au_vdir_deblk_p p; ++ unsigned char *o; ++ ++ if (!vdir || IS_ERR(vdir)) { ++ dpri("err %ld\n", PTR_ERR(vdir)); ++ return; ++ } ++ ++ dpri("deblk %u, nblk %lu, deblk %p, last{%lu, %p}, ver %llu\n", ++ vdir->vd_deblk_sz, vdir->vd_nblk, vdir->vd_deblk, ++ vdir->vd_last.ul, vdir->vd_last.p.deblk, vdir->vd_version); ++ for (ul = 0; ul < vdir->vd_nblk; ul++) { ++ p.deblk = vdir->vd_deblk[ul]; ++ o = p.deblk; ++ dpri("[%lu]: %p\n", ul, o); ++ } ++} ++ ++static int do_pri_inode(aufs_bindex_t bindex, struct inode *inode, int hn, ++ struct dentry *wh) ++{ ++ char *n = NULL; ++ int l = 0; ++ ++ if (!inode || IS_ERR(inode)) { ++ dpri("i%d: err %ld\n", bindex, PTR_ERR(inode)); ++ return -1; ++ } ++ ++ /* the type of i_blocks depends upon CONFIG_LBDAF */ ++ BUILD_BUG_ON(sizeof(inode->i_blocks) != sizeof(unsigned long) ++ && sizeof(inode->i_blocks) != sizeof(u64)); ++ if (wh) { ++ n = (void *)wh->d_name.name; ++ l = wh->d_name.len; ++ } ++ ++ dpri("i%d: %p, i%lu, %s, cnt %d, nl %u, 0%o, sz %llu, blk %llu," ++ " hn %d, ct %lld, np %lu, st 0x%lx, f 0x%x, v %llu, g %x%s%.*s\n", ++ bindex, inode, ++ inode->i_ino, inode->i_sb ? au_sbtype(inode->i_sb) : "??", ++ atomic_read(&inode->i_count), inode->i_nlink, inode->i_mode, ++ i_size_read(inode), (unsigned long long)inode->i_blocks, ++ hn, (long long)timespec64_to_ns(&inode->i_ctime) & 0x0ffff, ++ inode->i_mapping ? inode->i_mapping->nrpages : 0, ++ inode->i_state, inode->i_flags, inode_peek_iversion(inode), ++ inode->i_generation, ++ l ? ", wh " : "", l, n); ++ return 0; ++} ++ ++void au_dpri_inode(struct inode *inode) ++{ ++ struct au_iinfo *iinfo; ++ struct au_hinode *hi; ++ aufs_bindex_t bindex; ++ int err, hn; ++ ++ err = do_pri_inode(-1, inode, -1, NULL); ++ if (err || !au_test_aufs(inode->i_sb) || au_is_bad_inode(inode)) ++ return; ++ ++ iinfo = au_ii(inode); ++ dpri("i-1: btop %d, bbot %d, gen %d\n", ++ iinfo->ii_btop, iinfo->ii_bbot, au_iigen(inode, NULL)); ++ if (iinfo->ii_btop < 0) ++ return; ++ hn = 0; ++ for (bindex = iinfo->ii_btop; bindex <= iinfo->ii_bbot; bindex++) { ++ hi = au_hinode(iinfo, bindex); ++ hn = !!au_hn(hi); ++ do_pri_inode(bindex, hi->hi_inode, hn, hi->hi_whdentry); ++ } ++} ++ ++void au_dpri_dalias(struct inode *inode) ++{ ++ struct dentry *d; ++ ++ spin_lock(&inode->i_lock); ++ hlist_for_each_entry(d, &inode->i_dentry, d_u.d_alias) ++ au_dpri_dentry(d); ++ spin_unlock(&inode->i_lock); ++} ++ ++static int do_pri_dentry(aufs_bindex_t bindex, struct dentry *dentry) ++{ ++ struct dentry *wh = NULL; ++ int hn; ++ struct inode *inode; ++ struct au_iinfo *iinfo; ++ struct au_hinode *hi; ++ ++ if (!dentry || IS_ERR(dentry)) { ++ dpri("d%d: err %ld\n", bindex, PTR_ERR(dentry)); ++ return -1; ++ } ++ /* do not call dget_parent() here */ ++ /* note: access d_xxx without d_lock */ ++ dpri("d%d: %p, %pd2?, %s, cnt %d, flags 0x%x, %shashed\n", ++ bindex, dentry, dentry, ++ dentry->d_sb ? au_sbtype(dentry->d_sb) : "??", ++ au_dcount(dentry), dentry->d_flags, ++ d_unhashed(dentry) ? "un" : ""); ++ hn = -1; ++ inode = NULL; ++ if (d_is_positive(dentry)) ++ inode = d_inode(dentry); ++ if (inode ++ && au_test_aufs(dentry->d_sb) ++ && bindex >= 0 ++ && !au_is_bad_inode(inode)) { ++ iinfo = au_ii(inode); ++ hi = au_hinode(iinfo, bindex); ++ hn = !!au_hn(hi); ++ wh = hi->hi_whdentry; ++ } ++ do_pri_inode(bindex, inode, hn, wh); ++ return 0; ++} ++ ++void au_dpri_dentry(struct dentry *dentry) ++{ ++ struct au_dinfo *dinfo; ++ aufs_bindex_t bindex; ++ int err; ++ ++ err = do_pri_dentry(-1, dentry); ++ if (err || !au_test_aufs(dentry->d_sb)) ++ return; ++ ++ dinfo = au_di(dentry); ++ if (!dinfo) ++ return; ++ dpri("d-1: btop %d, bbot %d, bwh %d, bdiropq %d, gen %d, tmp %d\n", ++ dinfo->di_btop, dinfo->di_bbot, ++ dinfo->di_bwh, dinfo->di_bdiropq, au_digen(dentry), ++ dinfo->di_tmpfile); ++ if (dinfo->di_btop < 0) ++ return; ++ for (bindex = dinfo->di_btop; bindex <= dinfo->di_bbot; bindex++) ++ do_pri_dentry(bindex, au_hdentry(dinfo, bindex)->hd_dentry); ++} ++ ++static int do_pri_file(aufs_bindex_t bindex, struct file *file) ++{ ++ char a[32]; ++ ++ if (!file || IS_ERR(file)) { ++ dpri("f%d: err %ld\n", bindex, PTR_ERR(file)); ++ return -1; ++ } ++ a[0] = 0; ++ if (bindex < 0 ++ && !IS_ERR_OR_NULL(file->f_path.dentry) ++ && au_test_aufs(file->f_path.dentry->d_sb) ++ && au_fi(file)) ++ snprintf(a, sizeof(a), ", gen %d, mmapped %d", ++ au_figen(file), atomic_read(&au_fi(file)->fi_mmapped)); ++ dpri("f%d: mode 0x%x, flags 0%o, cnt %ld, v %llu, pos %llu%s\n", ++ bindex, file->f_mode, file->f_flags, (long)file_count(file), ++ file->f_version, file->f_pos, a); ++ if (!IS_ERR_OR_NULL(file->f_path.dentry)) ++ do_pri_dentry(bindex, file->f_path.dentry); ++ return 0; ++} ++ ++void au_dpri_file(struct file *file) ++{ ++ struct au_finfo *finfo; ++ struct au_fidir *fidir; ++ struct au_hfile *hfile; ++ aufs_bindex_t bindex; ++ int err; ++ ++ err = do_pri_file(-1, file); ++ if (err ++ || IS_ERR_OR_NULL(file->f_path.dentry) ++ || !au_test_aufs(file->f_path.dentry->d_sb)) ++ return; ++ ++ finfo = au_fi(file); ++ if (!finfo) ++ return; ++ if (finfo->fi_btop < 0) ++ return; ++ fidir = finfo->fi_hdir; ++ if (!fidir) ++ do_pri_file(finfo->fi_btop, finfo->fi_htop.hf_file); ++ else ++ for (bindex = finfo->fi_btop; ++ bindex >= 0 && bindex <= fidir->fd_bbot; ++ bindex++) { ++ hfile = fidir->fd_hfile + bindex; ++ do_pri_file(bindex, hfile ? hfile->hf_file : NULL); ++ } ++} ++ ++static int do_pri_br(aufs_bindex_t bindex, struct au_branch *br) ++{ ++ struct vfsmount *mnt; ++ struct super_block *sb; ++ ++ if (!br || IS_ERR(br)) ++ goto out; ++ mnt = au_br_mnt(br); ++ if (!mnt || IS_ERR(mnt)) ++ goto out; ++ sb = mnt->mnt_sb; ++ if (!sb || IS_ERR(sb)) ++ goto out; ++ ++ dpri("s%d: {perm 0x%x, id %d, wbr %p}, " ++ "%s, dev 0x%02x%02x, flags 0x%lx, cnt %d, active %d, " ++ "xino %d\n", ++ bindex, br->br_perm, br->br_id, br->br_wbr, ++ au_sbtype(sb), MAJOR(sb->s_dev), MINOR(sb->s_dev), ++ sb->s_flags, sb->s_count, ++ atomic_read(&sb->s_active), ++ !!au_xino_file(br->br_xino, /*idx*/-1)); ++ return 0; ++ ++out: ++ dpri("s%d: err %ld\n", bindex, PTR_ERR(br)); ++ return -1; ++} ++ ++void au_dpri_sb(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ aufs_bindex_t bindex; ++ int err; ++ /* to reduce stack size */ ++ struct { ++ struct vfsmount mnt; ++ struct au_branch fake; ++ } *a; ++ ++ /* this function can be called from magic sysrq */ ++ a = kzalloc(sizeof(*a), GFP_ATOMIC); ++ if (unlikely(!a)) { ++ dpri("no memory\n"); ++ return; ++ } ++ ++ a->mnt.mnt_sb = sb; ++ a->fake.br_path.mnt = &a->mnt; ++ err = do_pri_br(-1, &a->fake); ++ au_kfree_rcu(a); ++ dpri("dev 0x%x\n", sb->s_dev); ++ if (err || !au_test_aufs(sb)) ++ return; ++ ++ sbinfo = au_sbi(sb); ++ if (!sbinfo) ++ return; ++ dpri("nw %d, gen %u, kobj %d\n", ++ atomic_read(&sbinfo->si_nowait.nw_len), sbinfo->si_generation, ++ kref_read(&sbinfo->si_kobj.kref)); ++ for (bindex = 0; bindex <= sbinfo->si_bbot; bindex++) ++ do_pri_br(bindex, sbinfo->si_branch[0 + bindex]); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void __au_dbg_verify_dinode(struct dentry *dentry, const char *func, int line) ++{ ++ struct inode *h_inode, *inode = d_inode(dentry); ++ struct dentry *h_dentry; ++ aufs_bindex_t bindex, bbot, bi; ++ ++ if (!inode /* || au_di(dentry)->di_lsc == AuLsc_DI_TMP */) ++ return; ++ ++ bbot = au_dbbot(dentry); ++ bi = au_ibbot(inode); ++ if (bi < bbot) ++ bbot = bi; ++ bindex = au_dbtop(dentry); ++ bi = au_ibtop(inode); ++ if (bi > bindex) ++ bindex = bi; ++ ++ for (; bindex <= bbot; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ h_inode = au_h_iptr(inode, bindex); ++ if (unlikely(h_inode != d_inode(h_dentry))) { ++ au_debug_on(); ++ AuDbg("b%d, %s:%d\n", bindex, func, line); ++ AuDbgDentry(dentry); ++ AuDbgInode(inode); ++ au_debug_off(); ++ BUG(); ++ } ++ } ++} ++ ++void au_dbg_verify_gen(struct dentry *parent, unsigned int sigen) ++{ ++ int err, i, j; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ AuDebugOn(err); ++ err = au_dcsub_pages_rev_aufs(&dpages, parent, /*do_include*/1); ++ AuDebugOn(err); ++ for (i = dpages.ndpage - 1; !err && i >= 0; i--) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ for (j = dpage->ndentry - 1; !err && j >= 0; j--) ++ AuDebugOn(au_digen_test(dentries[j], sigen)); ++ } ++ au_dpages_free(&dpages); ++} ++ ++void au_dbg_verify_kthread(void) ++{ ++ if (au_wkq_test()) { ++ au_dbg_blocked(); ++ /* ++ * It may be recursive, but udba=notify between two aufs mounts, ++ * where a single ro branch is shared, is not a problem. ++ */ ++ /* WARN_ON(1); */ ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int __init au_debug_init(void) ++{ ++ aufs_bindex_t bindex; ++ struct au_vdir_destr destr; ++ ++ bindex = -1; ++ AuDebugOn(bindex >= 0); ++ ++ destr.len = -1; ++ AuDebugOn(destr.len < NAME_MAX); ++ ++#ifdef CONFIG_4KSTACKS ++ pr_warn("CONFIG_4KSTACKS is defined.\n"); ++#endif ++ ++ return 0; ++} +diff --git a/fs/aufs/debug.h b/fs/aufs/debug.h +new file mode 100644 +index 000000000000..5799794de0c2 +--- /dev/null ++++ b/fs/aufs/debug.h +@@ -0,0 +1,213 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * debug print functions ++ */ ++ ++#ifndef __AUFS_DEBUG_H__ ++#define __AUFS_DEBUG_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++#include ++#include ++ ++#ifdef CONFIG_AUFS_DEBUG ++#define AuDebugOn(a) BUG_ON(a) ++ ++/* module parameter */ ++extern atomic_t aufs_debug; ++static inline void au_debug_on(void) ++{ ++ atomic_inc(&aufs_debug); ++} ++static inline void au_debug_off(void) ++{ ++ atomic_dec_if_positive(&aufs_debug); ++} ++ ++static inline int au_debug_test(void) ++{ ++ return atomic_read(&aufs_debug) > 0; ++} ++#else ++#define AuDebugOn(a) do {} while (0) ++AuStubVoid(au_debug_on, void) ++AuStubVoid(au_debug_off, void) ++AuStubInt0(au_debug_test, void) ++#endif /* CONFIG_AUFS_DEBUG */ ++ ++#define param_check_atomic_t(name, p) __param_check(name, p, atomic_t) ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* debug print */ ++ ++#define AuDbg(fmt, ...) do { \ ++ if (au_debug_test()) \ ++ pr_debug("DEBUG: " fmt, ##__VA_ARGS__); \ ++} while (0) ++#define AuLabel(l) AuDbg(#l "\n") ++#define AuIOErr(fmt, ...) pr_err("I/O Error, " fmt, ##__VA_ARGS__) ++#define AuWarn1(fmt, ...) do { \ ++ static unsigned char _c; \ ++ if (!_c++) \ ++ pr_warn(fmt, ##__VA_ARGS__); \ ++} while (0) ++ ++#define AuErr1(fmt, ...) do { \ ++ static unsigned char _c; \ ++ if (!_c++) \ ++ pr_err(fmt, ##__VA_ARGS__); \ ++} while (0) ++ ++#define AuIOErr1(fmt, ...) do { \ ++ static unsigned char _c; \ ++ if (!_c++) \ ++ AuIOErr(fmt, ##__VA_ARGS__); \ ++} while (0) ++ ++#define AuUnsupportMsg "This operation is not supported." \ ++ " Please report this application to aufs-users ML." ++#define AuUnsupport(fmt, ...) do { \ ++ pr_err(AuUnsupportMsg "\n" fmt, ##__VA_ARGS__); \ ++ dump_stack(); \ ++} while (0) ++ ++#define AuTraceErr(e) do { \ ++ if (unlikely((e) < 0)) \ ++ AuDbg("err %d\n", (int)(e)); \ ++} while (0) ++ ++#define AuTraceErrPtr(p) do { \ ++ if (IS_ERR(p)) \ ++ AuDbg("err %ld\n", PTR_ERR(p)); \ ++} while (0) ++ ++/* dirty macros for debug print, use with "%.*s" and caution */ ++#define AuLNPair(qstr) (qstr)->len, (qstr)->name ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct dentry; ++#ifdef CONFIG_AUFS_DEBUG ++extern struct mutex au_dbg_mtx; ++extern char *au_plevel; ++struct au_nhash; ++void au_dpri_whlist(struct au_nhash *whlist); ++struct au_vdir; ++void au_dpri_vdir(struct au_vdir *vdir); ++struct inode; ++void au_dpri_inode(struct inode *inode); ++void au_dpri_dalias(struct inode *inode); ++void au_dpri_dentry(struct dentry *dentry); ++struct file; ++void au_dpri_file(struct file *filp); ++struct super_block; ++void au_dpri_sb(struct super_block *sb); ++ ++#define au_dbg_verify_dinode(d) __au_dbg_verify_dinode(d, __func__, __LINE__) ++void __au_dbg_verify_dinode(struct dentry *dentry, const char *func, int line); ++void au_dbg_verify_gen(struct dentry *parent, unsigned int sigen); ++void au_dbg_verify_kthread(void); ++ ++int __init au_debug_init(void); ++ ++#define AuDbgWhlist(w) do { \ ++ mutex_lock(&au_dbg_mtx); \ ++ AuDbg(#w "\n"); \ ++ au_dpri_whlist(w); \ ++ mutex_unlock(&au_dbg_mtx); \ ++} while (0) ++ ++#define AuDbgVdir(v) do { \ ++ mutex_lock(&au_dbg_mtx); \ ++ AuDbg(#v "\n"); \ ++ au_dpri_vdir(v); \ ++ mutex_unlock(&au_dbg_mtx); \ ++} while (0) ++ ++#define AuDbgInode(i) do { \ ++ mutex_lock(&au_dbg_mtx); \ ++ AuDbg(#i "\n"); \ ++ au_dpri_inode(i); \ ++ mutex_unlock(&au_dbg_mtx); \ ++} while (0) ++ ++#define AuDbgDAlias(i) do { \ ++ mutex_lock(&au_dbg_mtx); \ ++ AuDbg(#i "\n"); \ ++ au_dpri_dalias(i); \ ++ mutex_unlock(&au_dbg_mtx); \ ++} while (0) ++ ++#define AuDbgDentry(d) do { \ ++ mutex_lock(&au_dbg_mtx); \ ++ AuDbg(#d "\n"); \ ++ au_dpri_dentry(d); \ ++ mutex_unlock(&au_dbg_mtx); \ ++} while (0) ++ ++#define AuDbgFile(f) do { \ ++ mutex_lock(&au_dbg_mtx); \ ++ AuDbg(#f "\n"); \ ++ au_dpri_file(f); \ ++ mutex_unlock(&au_dbg_mtx); \ ++} while (0) ++ ++#define AuDbgSb(sb) do { \ ++ mutex_lock(&au_dbg_mtx); \ ++ AuDbg(#sb "\n"); \ ++ au_dpri_sb(sb); \ ++ mutex_unlock(&au_dbg_mtx); \ ++} while (0) ++ ++#define AuDbgSym(addr) do { \ ++ char sym[KSYM_SYMBOL_LEN]; \ ++ sprint_symbol(sym, (unsigned long)addr); \ ++ AuDbg("%s\n", sym); \ ++} while (0) ++#else ++AuStubVoid(au_dbg_verify_dinode, struct dentry *dentry) ++AuStubVoid(au_dbg_verify_gen, struct dentry *parent, unsigned int sigen) ++AuStubVoid(au_dbg_verify_kthread, void) ++AuStubInt0(__init au_debug_init, void) ++ ++#define AuDbgWhlist(w) do {} while (0) ++#define AuDbgVdir(v) do {} while (0) ++#define AuDbgInode(i) do {} while (0) ++#define AuDbgDAlias(i) do {} while (0) ++#define AuDbgDentry(d) do {} while (0) ++#define AuDbgFile(f) do {} while (0) ++#define AuDbgSb(sb) do {} while (0) ++#define AuDbgSym(addr) do {} while (0) ++#endif /* CONFIG_AUFS_DEBUG */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_MAGIC_SYSRQ ++int __init au_sysrq_init(void); ++void au_sysrq_fin(void); ++ ++#ifdef CONFIG_HW_CONSOLE ++#define au_dbg_blocked() do { \ ++ WARN_ON(1); \ ++ handle_sysrq('w'); \ ++} while (0) ++#else ++AuStubVoid(au_dbg_blocked, void) ++#endif ++ ++#else ++AuStubInt0(__init au_sysrq_init, void) ++AuStubVoid(au_sysrq_fin, void) ++AuStubVoid(au_dbg_blocked, void) ++#endif /* CONFIG_AUFS_MAGIC_SYSRQ */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DEBUG_H__ */ +diff --git a/fs/aufs/dentry.c b/fs/aufs/dentry.c +new file mode 100644 +index 000000000000..1a029193315a +--- /dev/null ++++ b/fs/aufs/dentry.c +@@ -0,0 +1,1141 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * lookup and dentry operations ++ */ ++ ++#include ++#include ++#include "aufs.h" ++ ++/* ++ * returns positive/negative dentry, NULL or an error. ++ * NULL means whiteout-ed or not-found. ++ */ ++static struct dentry* ++au_do_lookup(struct dentry *h_parent, struct dentry *dentry, ++ aufs_bindex_t bindex, struct au_do_lookup_args *args) ++{ ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ struct au_branch *br; ++ int wh_found, opq; ++ unsigned char wh_able; ++ const unsigned char allow_neg = !!au_ftest_lkup(args->flags, ALLOW_NEG); ++ const unsigned char ignore_perm = !!au_ftest_lkup(args->flags, ++ IGNORE_PERM); ++ ++ wh_found = 0; ++ br = au_sbr(dentry->d_sb, bindex); ++ wh_able = !!au_br_whable(br->br_perm); ++ if (wh_able) ++ wh_found = au_wh_test(h_parent, &args->whname, ignore_perm); ++ h_dentry = ERR_PTR(wh_found); ++ if (!wh_found) ++ goto real_lookup; ++ if (unlikely(wh_found < 0)) ++ goto out; ++ ++ /* We found a whiteout */ ++ /* au_set_dbbot(dentry, bindex); */ ++ au_set_dbwh(dentry, bindex); ++ if (!allow_neg) ++ return NULL; /* success */ ++ ++real_lookup: ++ if (!ignore_perm) ++ h_dentry = vfsub_lkup_one(args->name, h_parent); ++ else ++ h_dentry = au_sio_lkup_one(args->name, h_parent); ++ if (IS_ERR(h_dentry)) { ++ if (PTR_ERR(h_dentry) == -ENAMETOOLONG ++ && !allow_neg) ++ h_dentry = NULL; ++ goto out; ++ } ++ ++ h_inode = d_inode(h_dentry); ++ if (d_is_negative(h_dentry)) { ++ if (!allow_neg) ++ goto out_neg; ++ } else if (wh_found ++ || (args->type && args->type != (h_inode->i_mode & S_IFMT))) ++ goto out_neg; ++ else if (au_ftest_lkup(args->flags, DIRREN) ++ /* && h_inode */ ++ && !au_dr_lkup_h_ino(args, bindex, h_inode->i_ino)) { ++ AuDbg("b%d %pd ignored hi%llu\n", bindex, h_dentry, ++ (unsigned long long)h_inode->i_ino); ++ goto out_neg; ++ } ++ ++ if (au_dbbot(dentry) <= bindex) ++ au_set_dbbot(dentry, bindex); ++ if (au_dbtop(dentry) < 0 || bindex < au_dbtop(dentry)) ++ au_set_dbtop(dentry, bindex); ++ au_set_h_dptr(dentry, bindex, h_dentry); ++ ++ if (!d_is_dir(h_dentry) ++ || !wh_able ++ || (d_really_is_positive(dentry) && !d_is_dir(dentry))) ++ goto out; /* success */ ++ ++ inode_lock_shared_nested(h_inode, AuLsc_I_CHILD); ++ opq = au_diropq_test(h_dentry); ++ inode_unlock_shared(h_inode); ++ if (opq > 0) ++ au_set_dbdiropq(dentry, bindex); ++ else if (unlikely(opq < 0)) { ++ au_set_h_dptr(dentry, bindex, NULL); ++ h_dentry = ERR_PTR(opq); ++ } ++ goto out; ++ ++out_neg: ++ dput(h_dentry); ++ h_dentry = NULL; ++out: ++ return h_dentry; ++} ++ ++static int au_test_shwh(struct super_block *sb, const struct qstr *name) ++{ ++ if (unlikely(!au_opt_test(au_mntflags(sb), SHWH) ++ && !strncmp(name->name, AUFS_WH_PFX, AUFS_WH_PFX_LEN))) ++ return -EPERM; ++ return 0; ++} ++ ++/* ++ * returns the number of lower positive dentries, ++ * otherwise an error. ++ * can be called at unlinking with @type is zero. ++ */ ++int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t btop, ++ unsigned int flags) ++{ ++ int npositive, err; ++ aufs_bindex_t bindex, btail, bdiropq; ++ unsigned char isdir, dirperm1, dirren; ++ struct au_do_lookup_args args = { ++ .flags = flags, ++ .name = &dentry->d_name ++ }; ++ struct dentry *parent; ++ struct super_block *sb; ++ ++ sb = dentry->d_sb; ++ err = au_test_shwh(sb, args.name); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_wh_name_alloc(&args.whname, args.name); ++ if (unlikely(err)) ++ goto out; ++ ++ isdir = !!d_is_dir(dentry); ++ dirperm1 = !!au_opt_test(au_mntflags(sb), DIRPERM1); ++ dirren = !!au_opt_test(au_mntflags(sb), DIRREN); ++ if (dirren) ++ au_fset_lkup(args.flags, DIRREN); ++ ++ npositive = 0; ++ parent = dget_parent(dentry); ++ btail = au_dbtaildir(parent); ++ for (bindex = btop; bindex <= btail; bindex++) { ++ struct dentry *h_parent, *h_dentry; ++ struct inode *h_inode, *h_dir; ++ struct au_branch *br; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry) { ++ if (d_is_positive(h_dentry)) ++ npositive++; ++ break; ++ } ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || !d_is_dir(h_parent)) ++ continue; ++ ++ if (dirren) { ++ /* if the inum matches, then use the prepared name */ ++ err = au_dr_lkup_name(&args, bindex); ++ if (unlikely(err)) ++ goto out_parent; ++ } ++ ++ h_dir = d_inode(h_parent); ++ inode_lock_shared_nested(h_dir, AuLsc_I_PARENT); ++ h_dentry = au_do_lookup(h_parent, dentry, bindex, &args); ++ inode_unlock_shared(h_dir); ++ err = PTR_ERR(h_dentry); ++ if (IS_ERR(h_dentry)) ++ goto out_parent; ++ if (h_dentry) ++ au_fclr_lkup(args.flags, ALLOW_NEG); ++ if (dirperm1) ++ au_fset_lkup(args.flags, IGNORE_PERM); ++ ++ if (au_dbwh(dentry) == bindex) ++ break; ++ if (!h_dentry) ++ continue; ++ if (d_is_negative(h_dentry)) ++ continue; ++ h_inode = d_inode(h_dentry); ++ npositive++; ++ if (!args.type) ++ args.type = h_inode->i_mode & S_IFMT; ++ if (args.type != S_IFDIR) ++ break; ++ else if (isdir) { ++ /* the type of lower may be different */ ++ bdiropq = au_dbdiropq(dentry); ++ if (bdiropq >= 0 && bdiropq <= bindex) ++ break; ++ } ++ br = au_sbr(sb, bindex); ++ if (dirren ++ && au_dr_hino_test_add(&br->br_dirren, h_inode->i_ino, ++ /*add_ent*/NULL)) { ++ /* prepare next name to lookup */ ++ err = au_dr_lkup(&args, dentry, bindex); ++ if (unlikely(err)) ++ goto out_parent; ++ } ++ } ++ ++ if (npositive) { ++ AuLabel(positive); ++ au_update_dbtop(dentry); ++ } ++ err = npositive; ++ if (unlikely(!au_opt_test(au_mntflags(sb), UDBA_NONE) ++ && au_dbtop(dentry) < 0)) { ++ err = -EIO; ++ AuIOErr("both of real entry and whiteout found, %pd, err %d\n", ++ dentry, err); ++ } ++ ++out_parent: ++ dput(parent); ++ au_kfree_try_rcu(args.whname.name); ++ if (dirren) ++ au_dr_lkup_fin(&args); ++out: ++ return err; ++} ++ ++struct dentry *au_sio_lkup_one(struct qstr *name, struct dentry *parent) ++{ ++ struct dentry *dentry; ++ int wkq_err; ++ ++ if (!au_test_h_perm_sio(d_inode(parent), MAY_EXEC)) ++ dentry = vfsub_lkup_one(name, parent); ++ else { ++ struct vfsub_lkup_one_args args = { ++ .errp = &dentry, ++ .name = name, ++ .parent = parent ++ }; ++ ++ wkq_err = au_wkq_wait(vfsub_call_lkup_one, &args); ++ if (unlikely(wkq_err)) ++ dentry = ERR_PTR(wkq_err); ++ } ++ ++ return dentry; ++} ++ ++/* ++ * lookup @dentry on @bindex which should be negative. ++ */ ++int au_lkup_neg(struct dentry *dentry, aufs_bindex_t bindex, int wh) ++{ ++ int err; ++ struct dentry *parent, *h_parent, *h_dentry; ++ struct au_branch *br; ++ ++ parent = dget_parent(dentry); ++ h_parent = au_h_dptr(parent, bindex); ++ br = au_sbr(dentry->d_sb, bindex); ++ if (wh) ++ h_dentry = au_whtmp_lkup(h_parent, br, &dentry->d_name); ++ else ++ h_dentry = au_sio_lkup_one(&dentry->d_name, h_parent); ++ err = PTR_ERR(h_dentry); ++ if (IS_ERR(h_dentry)) ++ goto out; ++ if (unlikely(d_is_positive(h_dentry))) { ++ err = -EIO; ++ AuIOErr("%pd should be negative on b%d.\n", h_dentry, bindex); ++ dput(h_dentry); ++ goto out; ++ } ++ ++ err = 0; ++ if (bindex < au_dbtop(dentry)) ++ au_set_dbtop(dentry, bindex); ++ if (au_dbbot(dentry) < bindex) ++ au_set_dbbot(dentry, bindex); ++ au_set_h_dptr(dentry, bindex, h_dentry); ++ ++out: ++ dput(parent); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* subset of struct inode */ ++struct au_iattr { ++ unsigned long i_ino; ++ /* unsigned int i_nlink; */ ++ kuid_t i_uid; ++ kgid_t i_gid; ++ u64 i_version; ++/* ++ loff_t i_size; ++ blkcnt_t i_blocks; ++*/ ++ umode_t i_mode; ++}; ++ ++static void au_iattr_save(struct au_iattr *ia, struct inode *h_inode) ++{ ++ ia->i_ino = h_inode->i_ino; ++ /* ia->i_nlink = h_inode->i_nlink; */ ++ ia->i_uid = h_inode->i_uid; ++ ia->i_gid = h_inode->i_gid; ++ ia->i_version = inode_query_iversion(h_inode); ++/* ++ ia->i_size = h_inode->i_size; ++ ia->i_blocks = h_inode->i_blocks; ++*/ ++ ia->i_mode = (h_inode->i_mode & S_IFMT); ++} ++ ++static int au_iattr_test(struct au_iattr *ia, struct inode *h_inode) ++{ ++ return ia->i_ino != h_inode->i_ino ++ /* || ia->i_nlink != h_inode->i_nlink */ ++ || !uid_eq(ia->i_uid, h_inode->i_uid) ++ || !gid_eq(ia->i_gid, h_inode->i_gid) ++ || !inode_eq_iversion(h_inode, ia->i_version) ++/* ++ || ia->i_size != h_inode->i_size ++ || ia->i_blocks != h_inode->i_blocks ++*/ ++ || ia->i_mode != (h_inode->i_mode & S_IFMT); ++} ++ ++static int au_h_verify_dentry(struct dentry *h_dentry, struct dentry *h_parent, ++ struct au_branch *br) ++{ ++ int err; ++ struct au_iattr ia; ++ struct inode *h_inode; ++ struct dentry *h_d; ++ struct super_block *h_sb; ++ ++ err = 0; ++ memset(&ia, -1, sizeof(ia)); ++ h_sb = h_dentry->d_sb; ++ h_inode = NULL; ++ if (d_is_positive(h_dentry)) { ++ h_inode = d_inode(h_dentry); ++ au_iattr_save(&ia, h_inode); ++ } else if (au_test_nfs(h_sb) || au_test_fuse(h_sb)) ++ /* nfs d_revalidate may return 0 for negative dentry */ ++ /* fuse d_revalidate always return 0 for negative dentry */ ++ goto out; ++ ++ /* main purpose is namei.c:cached_lookup() and d_revalidate */ ++ h_d = vfsub_lkup_one(&h_dentry->d_name, h_parent); ++ err = PTR_ERR(h_d); ++ if (IS_ERR(h_d)) ++ goto out; ++ ++ err = 0; ++ if (unlikely(h_d != h_dentry ++ || d_inode(h_d) != h_inode ++ || (h_inode && au_iattr_test(&ia, h_inode)))) ++ err = au_busy_or_stale(); ++ dput(h_d); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_h_verify(struct dentry *h_dentry, unsigned int udba, struct inode *h_dir, ++ struct dentry *h_parent, struct au_branch *br) ++{ ++ int err; ++ ++ err = 0; ++ if (udba == AuOpt_UDBA_REVAL ++ && !au_test_fs_remote(h_dentry->d_sb)) { ++ IMustLock(h_dir); ++ err = (d_inode(h_dentry->d_parent) != h_dir); ++ } else if (udba != AuOpt_UDBA_NONE) ++ err = au_h_verify_dentry(h_dentry, h_parent, br); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_do_refresh_hdentry(struct dentry *dentry, struct dentry *parent) ++{ ++ int err; ++ aufs_bindex_t new_bindex, bindex, bbot, bwh, bdiropq; ++ struct au_hdentry tmp, *p, *q; ++ struct au_dinfo *dinfo; ++ struct super_block *sb; ++ ++ DiMustWriteLock(dentry); ++ ++ sb = dentry->d_sb; ++ dinfo = au_di(dentry); ++ bbot = dinfo->di_bbot; ++ bwh = dinfo->di_bwh; ++ bdiropq = dinfo->di_bdiropq; ++ bindex = dinfo->di_btop; ++ p = au_hdentry(dinfo, bindex); ++ for (; bindex <= bbot; bindex++, p++) { ++ if (!p->hd_dentry) ++ continue; ++ ++ new_bindex = au_br_index(sb, p->hd_id); ++ if (new_bindex == bindex) ++ continue; ++ ++ if (dinfo->di_bwh == bindex) ++ bwh = new_bindex; ++ if (dinfo->di_bdiropq == bindex) ++ bdiropq = new_bindex; ++ if (new_bindex < 0) { ++ au_hdput(p); ++ p->hd_dentry = NULL; ++ continue; ++ } ++ ++ /* swap two lower dentries, and loop again */ ++ q = au_hdentry(dinfo, new_bindex); ++ tmp = *q; ++ *q = *p; ++ *p = tmp; ++ if (tmp.hd_dentry) { ++ bindex--; ++ p--; ++ } ++ } ++ ++ dinfo->di_bwh = -1; ++ if (bwh >= 0 && bwh <= au_sbbot(sb) && au_sbr_whable(sb, bwh)) ++ dinfo->di_bwh = bwh; ++ ++ dinfo->di_bdiropq = -1; ++ if (bdiropq >= 0 ++ && bdiropq <= au_sbbot(sb) ++ && au_sbr_whable(sb, bdiropq)) ++ dinfo->di_bdiropq = bdiropq; ++ ++ err = -EIO; ++ dinfo->di_btop = -1; ++ dinfo->di_bbot = -1; ++ bbot = au_dbbot(parent); ++ bindex = 0; ++ p = au_hdentry(dinfo, bindex); ++ for (; bindex <= bbot; bindex++, p++) ++ if (p->hd_dentry) { ++ dinfo->di_btop = bindex; ++ break; ++ } ++ ++ if (dinfo->di_btop >= 0) { ++ bindex = bbot; ++ p = au_hdentry(dinfo, bindex); ++ for (; bindex >= 0; bindex--, p--) ++ if (p->hd_dentry) { ++ dinfo->di_bbot = bindex; ++ err = 0; ++ break; ++ } ++ } ++ ++ return err; ++} ++ ++static void au_do_hide(struct dentry *dentry) ++{ ++ struct inode *inode; ++ ++ if (d_really_is_positive(dentry)) { ++ inode = d_inode(dentry); ++ if (!d_is_dir(dentry)) { ++ if (inode->i_nlink && !d_unhashed(dentry)) ++ drop_nlink(inode); ++ } else { ++ clear_nlink(inode); ++ /* stop next lookup */ ++ inode->i_flags |= S_DEAD; ++ } ++ smp_mb(); /* necessary? */ ++ } ++ d_drop(dentry); ++} ++ ++static int au_hide_children(struct dentry *parent) ++{ ++ int err, i, j, ndentry; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry *dentry; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_dcsub_pages(&dpages, parent, NULL, NULL); ++ if (unlikely(err)) ++ goto out_dpages; ++ ++ /* in reverse order */ ++ for (i = dpages.ndpage - 1; i >= 0; i--) { ++ dpage = dpages.dpages + i; ++ ndentry = dpage->ndentry; ++ for (j = ndentry - 1; j >= 0; j--) { ++ dentry = dpage->dentries[j]; ++ if (dentry != parent) ++ au_do_hide(dentry); ++ } ++ } ++ ++out_dpages: ++ au_dpages_free(&dpages); ++out: ++ return err; ++} ++ ++static void au_hide(struct dentry *dentry) ++{ ++ int err; ++ ++ AuDbgDentry(dentry); ++ if (d_is_dir(dentry)) { ++ /* shrink_dcache_parent(dentry); */ ++ err = au_hide_children(dentry); ++ if (unlikely(err)) ++ AuIOErr("%pd, failed hiding children, ignored %d\n", ++ dentry, err); ++ } ++ au_do_hide(dentry); ++} ++ ++/* ++ * By adding a dirty branch, a cached dentry may be affected in various ways. ++ * ++ * a dirty branch is added ++ * - on the top of layers ++ * - in the middle of layers ++ * - to the bottom of layers ++ * ++ * on the added branch there exists ++ * - a whiteout ++ * - a diropq ++ * - a same named entry ++ * + exist ++ * * negative --> positive ++ * * positive --> positive ++ * - type is unchanged ++ * - type is changed ++ * + doesn't exist ++ * * negative --> negative ++ * * positive --> negative (rejected by au_br_del() for non-dir case) ++ * - none ++ */ ++static int au_refresh_by_dinfo(struct dentry *dentry, struct au_dinfo *dinfo, ++ struct au_dinfo *tmp) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ struct { ++ struct dentry *dentry; ++ struct inode *inode; ++ mode_t mode; ++ } orig_h, tmp_h = { ++ .dentry = NULL ++ }; ++ struct au_hdentry *hd; ++ struct inode *inode, *h_inode; ++ struct dentry *h_dentry; ++ ++ err = 0; ++ AuDebugOn(dinfo->di_btop < 0); ++ orig_h.mode = 0; ++ orig_h.dentry = au_hdentry(dinfo, dinfo->di_btop)->hd_dentry; ++ orig_h.inode = NULL; ++ if (d_is_positive(orig_h.dentry)) { ++ orig_h.inode = d_inode(orig_h.dentry); ++ orig_h.mode = orig_h.inode->i_mode & S_IFMT; ++ } ++ if (tmp->di_btop >= 0) { ++ tmp_h.dentry = au_hdentry(tmp, tmp->di_btop)->hd_dentry; ++ if (d_is_positive(tmp_h.dentry)) { ++ tmp_h.inode = d_inode(tmp_h.dentry); ++ tmp_h.mode = tmp_h.inode->i_mode & S_IFMT; ++ } ++ } ++ ++ inode = NULL; ++ if (d_really_is_positive(dentry)) ++ inode = d_inode(dentry); ++ if (!orig_h.inode) { ++ AuDbg("negative originally\n"); ++ if (inode) { ++ au_hide(dentry); ++ goto out; ++ } ++ AuDebugOn(inode); ++ AuDebugOn(dinfo->di_btop != dinfo->di_bbot); ++ AuDebugOn(dinfo->di_bdiropq != -1); ++ ++ if (!tmp_h.inode) { ++ AuDbg("negative --> negative\n"); ++ /* should have only one negative lower */ ++ if (tmp->di_btop >= 0 ++ && tmp->di_btop < dinfo->di_btop) { ++ AuDebugOn(tmp->di_btop != tmp->di_bbot); ++ AuDebugOn(dinfo->di_btop != dinfo->di_bbot); ++ au_set_h_dptr(dentry, dinfo->di_btop, NULL); ++ au_di_cp(dinfo, tmp); ++ hd = au_hdentry(tmp, tmp->di_btop); ++ au_set_h_dptr(dentry, tmp->di_btop, ++ dget(hd->hd_dentry)); ++ } ++ au_dbg_verify_dinode(dentry); ++ } else { ++ AuDbg("negative --> positive\n"); ++ /* ++ * similar to the behaviour of creating with bypassing ++ * aufs. ++ * unhash it in order to force an error in the ++ * succeeding create operation. ++ * we should not set S_DEAD here. ++ */ ++ d_drop(dentry); ++ /* au_di_swap(tmp, dinfo); */ ++ au_dbg_verify_dinode(dentry); ++ } ++ } else { ++ AuDbg("positive originally\n"); ++ /* inode may be NULL */ ++ AuDebugOn(inode && (inode->i_mode & S_IFMT) != orig_h.mode); ++ if (!tmp_h.inode) { ++ AuDbg("positive --> negative\n"); ++ /* or bypassing aufs */ ++ au_hide(dentry); ++ if (tmp->di_bwh >= 0 && tmp->di_bwh <= dinfo->di_btop) ++ dinfo->di_bwh = tmp->di_bwh; ++ if (inode) ++ err = au_refresh_hinode_self(inode); ++ au_dbg_verify_dinode(dentry); ++ } else if (orig_h.mode == tmp_h.mode) { ++ AuDbg("positive --> positive, same type\n"); ++ if (!S_ISDIR(orig_h.mode) ++ && dinfo->di_btop > tmp->di_btop) { ++ /* ++ * similar to the behaviour of removing and ++ * creating. ++ */ ++ au_hide(dentry); ++ if (inode) ++ err = au_refresh_hinode_self(inode); ++ au_dbg_verify_dinode(dentry); ++ } else { ++ /* fill empty slots */ ++ if (dinfo->di_btop > tmp->di_btop) ++ dinfo->di_btop = tmp->di_btop; ++ if (dinfo->di_bbot < tmp->di_bbot) ++ dinfo->di_bbot = tmp->di_bbot; ++ dinfo->di_bwh = tmp->di_bwh; ++ dinfo->di_bdiropq = tmp->di_bdiropq; ++ bbot = dinfo->di_bbot; ++ bindex = tmp->di_btop; ++ hd = au_hdentry(tmp, bindex); ++ for (; bindex <= bbot; bindex++, hd++) { ++ if (au_h_dptr(dentry, bindex)) ++ continue; ++ h_dentry = hd->hd_dentry; ++ if (!h_dentry) ++ continue; ++ AuDebugOn(d_is_negative(h_dentry)); ++ h_inode = d_inode(h_dentry); ++ AuDebugOn(orig_h.mode ++ != (h_inode->i_mode ++ & S_IFMT)); ++ au_set_h_dptr(dentry, bindex, ++ dget(h_dentry)); ++ } ++ if (inode) ++ err = au_refresh_hinode(inode, dentry); ++ au_dbg_verify_dinode(dentry); ++ } ++ } else { ++ AuDbg("positive --> positive, different type\n"); ++ /* similar to the behaviour of removing and creating */ ++ au_hide(dentry); ++ if (inode) ++ err = au_refresh_hinode_self(inode); ++ au_dbg_verify_dinode(dentry); ++ } ++ } ++ ++out: ++ return err; ++} ++ ++void au_refresh_dop(struct dentry *dentry, int force_reval) ++{ ++ const struct dentry_operations *dop ++ = force_reval ? &aufs_dop : dentry->d_sb->s_d_op; ++ static const unsigned int mask ++ = DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE; ++ ++ BUILD_BUG_ON(sizeof(mask) != sizeof(dentry->d_flags)); ++ ++ if (dentry->d_op == dop) ++ return; ++ ++ AuDbg("%pd\n", dentry); ++ spin_lock(&dentry->d_lock); ++ if (dop == &aufs_dop) ++ dentry->d_flags |= mask; ++ else ++ dentry->d_flags &= ~mask; ++ dentry->d_op = dop; ++ spin_unlock(&dentry->d_lock); ++} ++ ++int au_refresh_dentry(struct dentry *dentry, struct dentry *parent) ++{ ++ int err, ebrange, nbr; ++ unsigned int sigen; ++ struct au_dinfo *dinfo, *tmp; ++ struct super_block *sb; ++ struct inode *inode; ++ ++ DiMustWriteLock(dentry); ++ AuDebugOn(IS_ROOT(dentry)); ++ AuDebugOn(d_really_is_negative(parent)); ++ ++ sb = dentry->d_sb; ++ sigen = au_sigen(sb); ++ err = au_digen_test(parent, sigen); ++ if (unlikely(err)) ++ goto out; ++ ++ nbr = au_sbbot(sb) + 1; ++ dinfo = au_di(dentry); ++ err = au_di_realloc(dinfo, nbr, /*may_shrink*/0); ++ if (unlikely(err)) ++ goto out; ++ ebrange = au_dbrange_test(dentry); ++ if (!ebrange) ++ ebrange = au_do_refresh_hdentry(dentry, parent); ++ ++ if (d_unhashed(dentry) || ebrange /* || dinfo->di_tmpfile */) { ++ AuDebugOn(au_dbtop(dentry) < 0 && au_dbbot(dentry) >= 0); ++ if (d_really_is_positive(dentry)) { ++ inode = d_inode(dentry); ++ err = au_refresh_hinode_self(inode); ++ } ++ au_dbg_verify_dinode(dentry); ++ if (!err) ++ goto out_dgen; /* success */ ++ goto out; ++ } ++ ++ /* temporary dinfo */ ++ AuDbgDentry(dentry); ++ err = -ENOMEM; ++ tmp = au_di_alloc(sb, AuLsc_DI_TMP); ++ if (unlikely(!tmp)) ++ goto out; ++ au_di_swap(tmp, dinfo); ++ /* returns the number of positive dentries */ ++ /* ++ * if current working dir is removed, it returns an error. ++ * but the dentry is legal. ++ */ ++ err = au_lkup_dentry(dentry, /*btop*/0, AuLkup_ALLOW_NEG); ++ AuDbgDentry(dentry); ++ au_di_swap(tmp, dinfo); ++ if (err == -ENOENT) ++ err = 0; ++ if (err >= 0) { ++ /* compare/refresh by dinfo */ ++ AuDbgDentry(dentry); ++ err = au_refresh_by_dinfo(dentry, dinfo, tmp); ++ au_dbg_verify_dinode(dentry); ++ AuTraceErr(err); ++ } ++ au_di_realloc(dinfo, nbr, /*may_shrink*/1); /* harmless if err */ ++ au_rw_write_unlock(&tmp->di_rwsem); ++ au_di_free(tmp); ++ if (unlikely(err)) ++ goto out; ++ ++out_dgen: ++ au_update_digen(dentry); ++out: ++ if (unlikely(err && !(dentry->d_flags & DCACHE_NFSFS_RENAMED))) { ++ AuIOErr("failed refreshing %pd, %d\n", dentry, err); ++ AuDbgDentry(dentry); ++ } ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_do_h_d_reval(struct dentry *h_dentry, unsigned int flags, ++ struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ int err, valid; ++ ++ err = 0; ++ if (!(h_dentry->d_flags & DCACHE_OP_REVALIDATE)) ++ goto out; ++ ++ AuDbg("b%d\n", bindex); ++ /* ++ * gave up supporting LOOKUP_CREATE/OPEN for lower fs, ++ * due to whiteout and branch permission. ++ */ ++ flags &= ~(/*LOOKUP_PARENT |*/ LOOKUP_OPEN | LOOKUP_CREATE ++ | LOOKUP_FOLLOW | LOOKUP_EXCL); ++ /* it may return tri-state */ ++ valid = h_dentry->d_op->d_revalidate(h_dentry, flags); ++ ++ if (unlikely(valid < 0)) ++ err = valid; ++ else if (!valid) ++ err = -EINVAL; ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* todo: remove this */ ++static int h_d_revalidate(struct dentry *dentry, struct inode *inode, ++ unsigned int flags, int do_udba, int dirren) ++{ ++ int err; ++ umode_t mode, h_mode; ++ aufs_bindex_t bindex, btail, btop, ibs, ibe; ++ unsigned char plus, unhashed, is_root, h_plus, h_nfs, tmpfile; ++ struct inode *h_inode, *h_cached_inode; ++ struct dentry *h_dentry; ++ struct qstr *name, *h_name; ++ ++ err = 0; ++ plus = 0; ++ mode = 0; ++ ibs = -1; ++ ibe = -1; ++ unhashed = !!d_unhashed(dentry); ++ is_root = !!IS_ROOT(dentry); ++ name = &dentry->d_name; ++ tmpfile = au_di(dentry)->di_tmpfile; ++ ++ /* ++ * Theoretically, REVAL test should be unnecessary in case of ++ * {FS,I}NOTIFY. ++ * But {fs,i}notify doesn't fire some necessary events, ++ * IN_ATTRIB for atime/nlink/pageio ++ * Let's do REVAL test too. ++ */ ++ if (do_udba && inode) { ++ mode = (inode->i_mode & S_IFMT); ++ plus = (inode->i_nlink > 0); ++ ibs = au_ibtop(inode); ++ ibe = au_ibbot(inode); ++ } ++ ++ btop = au_dbtop(dentry); ++ btail = btop; ++ if (inode && S_ISDIR(inode->i_mode)) ++ btail = au_dbtaildir(dentry); ++ for (bindex = btop; bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ ++ AuDbg("b%d, %pd\n", bindex, h_dentry); ++ h_nfs = !!au_test_nfs(h_dentry->d_sb); ++ spin_lock(&h_dentry->d_lock); ++ h_name = &h_dentry->d_name; ++ if (unlikely(do_udba ++ && !is_root ++ && ((!h_nfs ++ && (unhashed != !!d_unhashed(h_dentry) ++ || (!tmpfile && !dirren ++ && !au_qstreq(name, h_name)) ++ )) ++ || (h_nfs ++ && !(flags & LOOKUP_OPEN) ++ && (h_dentry->d_flags ++ & DCACHE_NFSFS_RENAMED))) ++ )) { ++ int h_unhashed; ++ ++ h_unhashed = d_unhashed(h_dentry); ++ spin_unlock(&h_dentry->d_lock); ++ AuDbg("unhash 0x%x 0x%x, %pd %pd\n", ++ unhashed, h_unhashed, dentry, h_dentry); ++ goto err; ++ } ++ spin_unlock(&h_dentry->d_lock); ++ ++ err = au_do_h_d_reval(h_dentry, flags, dentry, bindex); ++ if (unlikely(err)) ++ /* do not goto err, to keep the errno */ ++ break; ++ ++ /* todo: plink too? */ ++ if (!do_udba) ++ continue; ++ ++ /* UDBA tests */ ++ if (unlikely(!!inode != d_is_positive(h_dentry))) ++ goto err; ++ ++ h_inode = NULL; ++ if (d_is_positive(h_dentry)) ++ h_inode = d_inode(h_dentry); ++ h_plus = plus; ++ h_mode = mode; ++ h_cached_inode = h_inode; ++ if (h_inode) { ++ h_mode = (h_inode->i_mode & S_IFMT); ++ h_plus = (h_inode->i_nlink > 0); ++ } ++ if (inode && ibs <= bindex && bindex <= ibe) ++ h_cached_inode = au_h_iptr(inode, bindex); ++ ++ if (!h_nfs) { ++ if (unlikely(plus != h_plus && !tmpfile)) ++ goto err; ++ } else { ++ if (unlikely(!(h_dentry->d_flags & DCACHE_NFSFS_RENAMED) ++ && !is_root ++ && !IS_ROOT(h_dentry) ++ && unhashed != d_unhashed(h_dentry))) ++ goto err; ++ } ++ if (unlikely(mode != h_mode ++ || h_cached_inode != h_inode)) ++ goto err; ++ continue; ++ ++err: ++ err = -EINVAL; ++ break; ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++/* todo: consolidate with do_refresh() and au_reval_for_attr() */ ++static int simple_reval_dpath(struct dentry *dentry, unsigned int sigen) ++{ ++ int err; ++ struct dentry *parent; ++ ++ if (!au_digen_test(dentry, sigen)) ++ return 0; ++ ++ parent = dget_parent(dentry); ++ di_read_lock_parent(parent, AuLock_IR); ++ AuDebugOn(au_digen_test(parent, sigen)); ++ au_dbg_verify_gen(parent, sigen); ++ err = au_refresh_dentry(dentry, parent); ++ di_read_unlock(parent, AuLock_IR); ++ dput(parent); ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_reval_dpath(struct dentry *dentry, unsigned int sigen) ++{ ++ int err; ++ struct dentry *d, *parent; ++ ++ if (!au_ftest_si(au_sbi(dentry->d_sb), FAILED_REFRESH_DIR)) ++ return simple_reval_dpath(dentry, sigen); ++ ++ /* slow loop, keep it simple and stupid */ ++ /* cf: au_cpup_dirs() */ ++ err = 0; ++ parent = NULL; ++ while (au_digen_test(dentry, sigen)) { ++ d = dentry; ++ while (1) { ++ dput(parent); ++ parent = dget_parent(d); ++ if (!au_digen_test(parent, sigen)) ++ break; ++ d = parent; ++ } ++ ++ if (d != dentry) ++ di_write_lock_child2(d); ++ ++ /* someone might update our dentry while we were sleeping */ ++ if (au_digen_test(d, sigen)) { ++ /* ++ * todo: consolidate with simple_reval_dpath(), ++ * do_refresh() and au_reval_for_attr(). ++ */ ++ di_read_lock_parent(parent, AuLock_IR); ++ err = au_refresh_dentry(d, parent); ++ di_read_unlock(parent, AuLock_IR); ++ } ++ ++ if (d != dentry) ++ di_write_unlock(d); ++ dput(parent); ++ if (unlikely(err)) ++ break; ++ } ++ ++ return err; ++} ++ ++/* ++ * if valid returns 1, otherwise 0. ++ */ ++static int aufs_d_revalidate(struct dentry *dentry, unsigned int flags) ++{ ++ int valid, err; ++ unsigned int sigen; ++ unsigned char do_udba, dirren; ++ struct super_block *sb; ++ struct inode *inode; ++ ++ /* todo: support rcu-walk? */ ++ if (flags & LOOKUP_RCU) ++ return -ECHILD; ++ ++ valid = 0; ++ if (unlikely(!au_di(dentry))) ++ goto out; ++ ++ valid = 1; ++ sb = dentry->d_sb; ++ /* ++ * todo: very ugly ++ * i_mutex of parent dir may be held, ++ * but we should not return 'invalid' due to busy. ++ */ ++ err = aufs_read_lock(dentry, AuLock_FLUSH | AuLock_DW | AuLock_NOPLM); ++ if (unlikely(err)) { ++ valid = err; ++ AuTraceErr(err); ++ goto out; ++ } ++ inode = NULL; ++ if (d_really_is_positive(dentry)) ++ inode = d_inode(dentry); ++ if (unlikely(inode && au_is_bad_inode(inode))) { ++ err = -EINVAL; ++ AuTraceErr(err); ++ goto out_dgrade; ++ } ++ if (unlikely(au_dbrange_test(dentry))) { ++ err = -EINVAL; ++ AuTraceErr(err); ++ goto out_dgrade; ++ } ++ ++ sigen = au_sigen(sb); ++ if (au_digen_test(dentry, sigen)) { ++ AuDebugOn(IS_ROOT(dentry)); ++ err = au_reval_dpath(dentry, sigen); ++ if (unlikely(err)) { ++ AuTraceErr(err); ++ goto out_dgrade; ++ } ++ } ++ di_downgrade_lock(dentry, AuLock_IR); ++ ++ err = -EINVAL; ++ if (!(flags & (LOOKUP_OPEN | LOOKUP_EMPTY)) ++ && inode ++ && !(inode->i_state && I_LINKABLE) ++ && (IS_DEADDIR(inode) || !inode->i_nlink)) { ++ AuTraceErr(err); ++ goto out_inval; ++ } ++ ++ do_udba = !au_opt_test(au_mntflags(sb), UDBA_NONE); ++ if (do_udba && inode) { ++ aufs_bindex_t btop = au_ibtop(inode); ++ struct inode *h_inode; ++ ++ if (btop >= 0) { ++ h_inode = au_h_iptr(inode, btop); ++ if (h_inode && au_test_higen(inode, h_inode)) { ++ AuTraceErr(err); ++ goto out_inval; ++ } ++ } ++ } ++ ++ dirren = !!au_opt_test(au_mntflags(sb), DIRREN); ++ err = h_d_revalidate(dentry, inode, flags, do_udba, dirren); ++ if (unlikely(!err && do_udba && au_dbtop(dentry) < 0)) { ++ err = -EIO; ++ AuDbg("both of real entry and whiteout found, %p, err %d\n", ++ dentry, err); ++ } ++ goto out_inval; ++ ++out_dgrade: ++ di_downgrade_lock(dentry, AuLock_IR); ++out_inval: ++ aufs_read_unlock(dentry, AuLock_IR); ++ AuTraceErr(err); ++ valid = !err; ++out: ++ if (!valid) { ++ AuDbg("%pd invalid, %d\n", dentry, valid); ++ d_drop(dentry); ++ } ++ return valid; ++} ++ ++static void aufs_d_release(struct dentry *dentry) ++{ ++ if (au_di(dentry)) { ++ au_di_fin(dentry); ++ au_hn_di_reinit(dentry); ++ } ++} ++ ++const struct dentry_operations aufs_dop = { ++ .d_revalidate = aufs_d_revalidate, ++ .d_weak_revalidate = aufs_d_revalidate, ++ .d_release = aufs_d_release ++}; ++ ++/* aufs_dop without d_revalidate */ ++const struct dentry_operations aufs_dop_noreval = { ++ .d_release = aufs_d_release ++}; +diff --git a/fs/aufs/dentry.h b/fs/aufs/dentry.h +new file mode 100644 +index 000000000000..086f6ccf4b15 +--- /dev/null ++++ b/fs/aufs/dentry.h +@@ -0,0 +1,255 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * lookup and dentry operations ++ */ ++ ++#ifndef __AUFS_DENTRY_H__ ++#define __AUFS_DENTRY_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include "dirren.h" ++#include "rwsem.h" ++ ++struct au_hdentry { ++ struct dentry *hd_dentry; ++ aufs_bindex_t hd_id; ++}; ++ ++struct au_dinfo { ++ atomic_t di_generation; ++ ++ struct au_rwsem di_rwsem; ++ aufs_bindex_t di_btop, di_bbot, di_bwh, di_bdiropq; ++ unsigned char di_tmpfile; /* to allow the different name */ ++ struct au_hdentry *di_hdentry; ++ struct rcu_head rcu; ++} ____cacheline_aligned_in_smp; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* flags for au_lkup_dentry() */ ++#define AuLkup_ALLOW_NEG 1 ++#define AuLkup_IGNORE_PERM (1 << 1) ++#define AuLkup_DIRREN (1 << 2) ++#define au_ftest_lkup(flags, name) ((flags) & AuLkup_##name) ++#define au_fset_lkup(flags, name) \ ++ do { (flags) |= AuLkup_##name; } while (0) ++#define au_fclr_lkup(flags, name) \ ++ do { (flags) &= ~AuLkup_##name; } while (0) ++ ++#ifndef CONFIG_AUFS_DIRREN ++#undef AuLkup_DIRREN ++#define AuLkup_DIRREN 0 ++#endif ++ ++struct au_do_lookup_args { ++ unsigned int flags; ++ mode_t type; ++ struct qstr whname, *name; ++ struct au_dr_lookup dirren; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dentry.c */ ++extern const struct dentry_operations aufs_dop, aufs_dop_noreval; ++struct au_branch; ++struct dentry *au_sio_lkup_one(struct qstr *name, struct dentry *parent); ++int au_h_verify(struct dentry *h_dentry, unsigned int udba, struct inode *h_dir, ++ struct dentry *h_parent, struct au_branch *br); ++ ++int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t btop, ++ unsigned int flags); ++int au_lkup_neg(struct dentry *dentry, aufs_bindex_t bindex, int wh); ++int au_refresh_dentry(struct dentry *dentry, struct dentry *parent); ++int au_reval_dpath(struct dentry *dentry, unsigned int sigen); ++void au_refresh_dop(struct dentry *dentry, int force_reval); ++ ++/* dinfo.c */ ++void au_di_init_once(void *_di); ++struct au_dinfo *au_di_alloc(struct super_block *sb, unsigned int lsc); ++void au_di_free(struct au_dinfo *dinfo); ++void au_di_swap(struct au_dinfo *a, struct au_dinfo *b); ++void au_di_cp(struct au_dinfo *dst, struct au_dinfo *src); ++int au_di_init(struct dentry *dentry); ++void au_di_fin(struct dentry *dentry); ++int au_di_realloc(struct au_dinfo *dinfo, int nbr, int may_shrink); ++ ++void di_read_lock(struct dentry *d, int flags, unsigned int lsc); ++void di_read_unlock(struct dentry *d, int flags); ++void di_downgrade_lock(struct dentry *d, int flags); ++void di_write_lock(struct dentry *d, unsigned int lsc); ++void di_write_unlock(struct dentry *d); ++void di_write_lock2_child(struct dentry *d1, struct dentry *d2, int isdir); ++void di_write_lock2_parent(struct dentry *d1, struct dentry *d2, int isdir); ++void di_write_unlock2(struct dentry *d1, struct dentry *d2); ++ ++struct dentry *au_h_dptr(struct dentry *dentry, aufs_bindex_t bindex); ++struct dentry *au_h_d_alias(struct dentry *dentry, aufs_bindex_t bindex); ++aufs_bindex_t au_dbtail(struct dentry *dentry); ++aufs_bindex_t au_dbtaildir(struct dentry *dentry); ++ ++void au_set_h_dptr(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_dentry); ++int au_digen_test(struct dentry *dentry, unsigned int sigen); ++int au_dbrange_test(struct dentry *dentry); ++void au_update_digen(struct dentry *dentry); ++void au_update_dbrange(struct dentry *dentry, int do_put_zero); ++void au_update_dbtop(struct dentry *dentry); ++void au_update_dbbot(struct dentry *dentry); ++int au_find_dbindex(struct dentry *dentry, struct dentry *h_dentry); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_dinfo *au_di(struct dentry *dentry) ++{ ++ return dentry->d_fsdata; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock subclass for dinfo */ ++enum { ++ AuLsc_DI_CHILD, /* child first */ ++ AuLsc_DI_CHILD2, /* rename(2), link(2), and cpup at hnotify */ ++ AuLsc_DI_CHILD3, /* copyup dirs */ ++ AuLsc_DI_PARENT, ++ AuLsc_DI_PARENT2, ++ AuLsc_DI_PARENT3, ++ AuLsc_DI_TMP /* temp for replacing dinfo */ ++}; ++ ++/* ++ * di_read_lock_child, di_write_lock_child, ++ * di_read_lock_child2, di_write_lock_child2, ++ * di_read_lock_child3, di_write_lock_child3, ++ * di_read_lock_parent, di_write_lock_parent, ++ * di_read_lock_parent2, di_write_lock_parent2, ++ * di_read_lock_parent3, di_write_lock_parent3, ++ */ ++#define AuReadLockFunc(name, lsc) \ ++static inline void di_read_lock_##name(struct dentry *d, int flags) \ ++{ di_read_lock(d, flags, AuLsc_DI_##lsc); } ++ ++#define AuWriteLockFunc(name, lsc) \ ++static inline void di_write_lock_##name(struct dentry *d) \ ++{ di_write_lock(d, AuLsc_DI_##lsc); } ++ ++#define AuRWLockFuncs(name, lsc) \ ++ AuReadLockFunc(name, lsc) \ ++ AuWriteLockFunc(name, lsc) ++ ++AuRWLockFuncs(child, CHILD); ++AuRWLockFuncs(child2, CHILD2); ++AuRWLockFuncs(child3, CHILD3); ++AuRWLockFuncs(parent, PARENT); ++AuRWLockFuncs(parent2, PARENT2); ++AuRWLockFuncs(parent3, PARENT3); ++ ++#undef AuReadLockFunc ++#undef AuWriteLockFunc ++#undef AuRWLockFuncs ++ ++#define DiMustNoWaiters(d) AuRwMustNoWaiters(&au_di(d)->di_rwsem) ++#define DiMustAnyLock(d) AuRwMustAnyLock(&au_di(d)->di_rwsem) ++#define DiMustWriteLock(d) AuRwMustWriteLock(&au_di(d)->di_rwsem) ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* todo: memory barrier? */ ++static inline unsigned int au_digen(struct dentry *d) ++{ ++ return atomic_read(&au_di(d)->di_generation); ++} ++ ++static inline void au_h_dentry_init(struct au_hdentry *hdentry) ++{ ++ hdentry->hd_dentry = NULL; ++} ++ ++static inline struct au_hdentry *au_hdentry(struct au_dinfo *di, ++ aufs_bindex_t bindex) ++{ ++ return di->di_hdentry + bindex; ++} ++ ++static inline void au_hdput(struct au_hdentry *hd) ++{ ++ if (hd) ++ dput(hd->hd_dentry); ++} ++ ++static inline aufs_bindex_t au_dbtop(struct dentry *dentry) ++{ ++ DiMustAnyLock(dentry); ++ return au_di(dentry)->di_btop; ++} ++ ++static inline aufs_bindex_t au_dbbot(struct dentry *dentry) ++{ ++ DiMustAnyLock(dentry); ++ return au_di(dentry)->di_bbot; ++} ++ ++static inline aufs_bindex_t au_dbwh(struct dentry *dentry) ++{ ++ DiMustAnyLock(dentry); ++ return au_di(dentry)->di_bwh; ++} ++ ++static inline aufs_bindex_t au_dbdiropq(struct dentry *dentry) ++{ ++ DiMustAnyLock(dentry); ++ return au_di(dentry)->di_bdiropq; ++} ++ ++/* todo: hard/soft set? */ ++static inline void au_set_dbtop(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ DiMustWriteLock(dentry); ++ au_di(dentry)->di_btop = bindex; ++} ++ ++static inline void au_set_dbbot(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ DiMustWriteLock(dentry); ++ au_di(dentry)->di_bbot = bindex; ++} ++ ++static inline void au_set_dbwh(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ DiMustWriteLock(dentry); ++ /* dbwh can be outside of btop - bbot range */ ++ au_di(dentry)->di_bwh = bindex; ++} ++ ++static inline void au_set_dbdiropq(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ DiMustWriteLock(dentry); ++ au_di(dentry)->di_bdiropq = bindex; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_HNOTIFY ++static inline void au_digen_dec(struct dentry *d) ++{ ++ atomic_dec(&au_di(d)->di_generation); ++} ++ ++static inline void au_hn_di_reinit(struct dentry *dentry) ++{ ++ dentry->d_fsdata = NULL; ++} ++#else ++AuStubVoid(au_hn_di_reinit, struct dentry *dentry __maybe_unused) ++#endif /* CONFIG_AUFS_HNOTIFY */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DENTRY_H__ */ +diff --git a/fs/aufs/dinfo.c b/fs/aufs/dinfo.c +new file mode 100644 +index 000000000000..aed5314e5e24 +--- /dev/null ++++ b/fs/aufs/dinfo.c +@@ -0,0 +1,541 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * dentry private data ++ */ ++ ++#include "aufs.h" ++ ++void au_di_init_once(void *_dinfo) ++{ ++ struct au_dinfo *dinfo = _dinfo; ++ ++ au_rw_init(&dinfo->di_rwsem); ++} ++ ++struct au_dinfo *au_di_alloc(struct super_block *sb, unsigned int lsc) ++{ ++ struct au_dinfo *dinfo; ++ int nbr, i; ++ ++ dinfo = au_cache_alloc_dinfo(); ++ if (unlikely(!dinfo)) ++ goto out; ++ ++ nbr = au_sbbot(sb) + 1; ++ if (nbr <= 0) ++ nbr = 1; ++ dinfo->di_hdentry = kcalloc(nbr, sizeof(*dinfo->di_hdentry), GFP_NOFS); ++ if (dinfo->di_hdentry) { ++ au_rw_write_lock_nested(&dinfo->di_rwsem, lsc); ++ dinfo->di_btop = -1; ++ dinfo->di_bbot = -1; ++ dinfo->di_bwh = -1; ++ dinfo->di_bdiropq = -1; ++ dinfo->di_tmpfile = 0; ++ for (i = 0; i < nbr; i++) ++ dinfo->di_hdentry[i].hd_id = -1; ++ goto out; ++ } ++ ++ au_cache_free_dinfo(dinfo); ++ dinfo = NULL; ++ ++out: ++ return dinfo; ++} ++ ++void au_di_free(struct au_dinfo *dinfo) ++{ ++ struct au_hdentry *p; ++ aufs_bindex_t bbot, bindex; ++ ++ /* dentry may not be revalidated */ ++ bindex = dinfo->di_btop; ++ if (bindex >= 0) { ++ bbot = dinfo->di_bbot; ++ p = au_hdentry(dinfo, bindex); ++ while (bindex++ <= bbot) ++ au_hdput(p++); ++ } ++ au_kfree_try_rcu(dinfo->di_hdentry); ++ au_cache_free_dinfo(dinfo); ++} ++ ++void au_di_swap(struct au_dinfo *a, struct au_dinfo *b) ++{ ++ struct au_hdentry *p; ++ aufs_bindex_t bi; ++ ++ AuRwMustWriteLock(&a->di_rwsem); ++ AuRwMustWriteLock(&b->di_rwsem); ++ ++#define DiSwap(v, name) \ ++ do { \ ++ v = a->di_##name; \ ++ a->di_##name = b->di_##name; \ ++ b->di_##name = v; \ ++ } while (0) ++ ++ DiSwap(p, hdentry); ++ DiSwap(bi, btop); ++ DiSwap(bi, bbot); ++ DiSwap(bi, bwh); ++ DiSwap(bi, bdiropq); ++ /* smp_mb(); */ ++ ++#undef DiSwap ++} ++ ++void au_di_cp(struct au_dinfo *dst, struct au_dinfo *src) ++{ ++ AuRwMustWriteLock(&dst->di_rwsem); ++ AuRwMustWriteLock(&src->di_rwsem); ++ ++ dst->di_btop = src->di_btop; ++ dst->di_bbot = src->di_bbot; ++ dst->di_bwh = src->di_bwh; ++ dst->di_bdiropq = src->di_bdiropq; ++ /* smp_mb(); */ ++} ++ ++int au_di_init(struct dentry *dentry) ++{ ++ int err; ++ struct super_block *sb; ++ struct au_dinfo *dinfo; ++ ++ err = 0; ++ sb = dentry->d_sb; ++ dinfo = au_di_alloc(sb, AuLsc_DI_CHILD); ++ if (dinfo) { ++ atomic_set(&dinfo->di_generation, au_sigen(sb)); ++ /* smp_mb(); */ /* atomic_set */ ++ dentry->d_fsdata = dinfo; ++ } else ++ err = -ENOMEM; ++ ++ return err; ++} ++ ++void au_di_fin(struct dentry *dentry) ++{ ++ struct au_dinfo *dinfo; ++ ++ dinfo = au_di(dentry); ++ AuRwDestroy(&dinfo->di_rwsem); ++ au_di_free(dinfo); ++} ++ ++int au_di_realloc(struct au_dinfo *dinfo, int nbr, int may_shrink) ++{ ++ int err, sz; ++ struct au_hdentry *hdp; ++ ++ AuRwMustWriteLock(&dinfo->di_rwsem); ++ ++ err = -ENOMEM; ++ sz = sizeof(*hdp) * (dinfo->di_bbot + 1); ++ if (!sz) ++ sz = sizeof(*hdp); ++ hdp = au_kzrealloc(dinfo->di_hdentry, sz, sizeof(*hdp) * nbr, GFP_NOFS, ++ may_shrink); ++ if (hdp) { ++ dinfo->di_hdentry = hdp; ++ err = 0; ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void do_ii_write_lock(struct inode *inode, unsigned int lsc) ++{ ++ switch (lsc) { ++ case AuLsc_DI_CHILD: ++ ii_write_lock_child(inode); ++ break; ++ case AuLsc_DI_CHILD2: ++ ii_write_lock_child2(inode); ++ break; ++ case AuLsc_DI_CHILD3: ++ ii_write_lock_child3(inode); ++ break; ++ case AuLsc_DI_PARENT: ++ ii_write_lock_parent(inode); ++ break; ++ case AuLsc_DI_PARENT2: ++ ii_write_lock_parent2(inode); ++ break; ++ case AuLsc_DI_PARENT3: ++ ii_write_lock_parent3(inode); ++ break; ++ default: ++ BUG(); ++ } ++} ++ ++static void do_ii_read_lock(struct inode *inode, unsigned int lsc) ++{ ++ switch (lsc) { ++ case AuLsc_DI_CHILD: ++ ii_read_lock_child(inode); ++ break; ++ case AuLsc_DI_CHILD2: ++ ii_read_lock_child2(inode); ++ break; ++ case AuLsc_DI_CHILD3: ++ ii_read_lock_child3(inode); ++ break; ++ case AuLsc_DI_PARENT: ++ ii_read_lock_parent(inode); ++ break; ++ case AuLsc_DI_PARENT2: ++ ii_read_lock_parent2(inode); ++ break; ++ case AuLsc_DI_PARENT3: ++ ii_read_lock_parent3(inode); ++ break; ++ default: ++ BUG(); ++ } ++} ++ ++void di_read_lock(struct dentry *d, int flags, unsigned int lsc) ++{ ++ struct inode *inode; ++ ++ au_rw_read_lock_nested(&au_di(d)->di_rwsem, lsc); ++ if (d_really_is_positive(d)) { ++ inode = d_inode(d); ++ if (au_ftest_lock(flags, IW)) ++ do_ii_write_lock(inode, lsc); ++ else if (au_ftest_lock(flags, IR)) ++ do_ii_read_lock(inode, lsc); ++ } ++} ++ ++void di_read_unlock(struct dentry *d, int flags) ++{ ++ struct inode *inode; ++ ++ if (d_really_is_positive(d)) { ++ inode = d_inode(d); ++ if (au_ftest_lock(flags, IW)) { ++ au_dbg_verify_dinode(d); ++ ii_write_unlock(inode); ++ } else if (au_ftest_lock(flags, IR)) { ++ au_dbg_verify_dinode(d); ++ ii_read_unlock(inode); ++ } ++ } ++ au_rw_read_unlock(&au_di(d)->di_rwsem); ++} ++ ++void di_downgrade_lock(struct dentry *d, int flags) ++{ ++ if (d_really_is_positive(d) && au_ftest_lock(flags, IR)) ++ ii_downgrade_lock(d_inode(d)); ++ au_rw_dgrade_lock(&au_di(d)->di_rwsem); ++} ++ ++void di_write_lock(struct dentry *d, unsigned int lsc) ++{ ++ au_rw_write_lock_nested(&au_di(d)->di_rwsem, lsc); ++ if (d_really_is_positive(d)) ++ do_ii_write_lock(d_inode(d), lsc); ++} ++ ++void di_write_unlock(struct dentry *d) ++{ ++ au_dbg_verify_dinode(d); ++ if (d_really_is_positive(d)) ++ ii_write_unlock(d_inode(d)); ++ au_rw_write_unlock(&au_di(d)->di_rwsem); ++} ++ ++void di_write_lock2_child(struct dentry *d1, struct dentry *d2, int isdir) ++{ ++ AuDebugOn(d1 == d2 ++ || d_inode(d1) == d_inode(d2) ++ || d1->d_sb != d2->d_sb); ++ ++ if ((isdir && au_test_subdir(d1, d2)) ++ || d1 < d2) { ++ di_write_lock_child(d1); ++ di_write_lock_child2(d2); ++ } else { ++ di_write_lock_child(d2); ++ di_write_lock_child2(d1); ++ } ++} ++ ++void di_write_lock2_parent(struct dentry *d1, struct dentry *d2, int isdir) ++{ ++ AuDebugOn(d1 == d2 ++ || d_inode(d1) == d_inode(d2) ++ || d1->d_sb != d2->d_sb); ++ ++ if ((isdir && au_test_subdir(d1, d2)) ++ || d1 < d2) { ++ di_write_lock_parent(d1); ++ di_write_lock_parent2(d2); ++ } else { ++ di_write_lock_parent(d2); ++ di_write_lock_parent2(d1); ++ } ++} ++ ++void di_write_unlock2(struct dentry *d1, struct dentry *d2) ++{ ++ di_write_unlock(d1); ++ if (d_inode(d1) == d_inode(d2)) ++ au_rw_write_unlock(&au_di(d2)->di_rwsem); ++ else ++ di_write_unlock(d2); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct dentry *au_h_dptr(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ struct dentry *d; ++ ++ DiMustAnyLock(dentry); ++ ++ if (au_dbtop(dentry) < 0 || bindex < au_dbtop(dentry)) ++ return NULL; ++ AuDebugOn(bindex < 0); ++ d = au_hdentry(au_di(dentry), bindex)->hd_dentry; ++ AuDebugOn(d && au_dcount(d) <= 0); ++ return d; ++} ++ ++/* ++ * extended version of au_h_dptr(). ++ * returns a hashed and positive (or linkable) h_dentry in bindex, NULL, or ++ * error. ++ */ ++struct dentry *au_h_d_alias(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ struct dentry *h_dentry; ++ struct inode *inode, *h_inode; ++ ++ AuDebugOn(d_really_is_negative(dentry)); ++ ++ h_dentry = NULL; ++ if (au_dbtop(dentry) <= bindex ++ && bindex <= au_dbbot(dentry)) ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry && !au_d_linkable(h_dentry)) { ++ dget(h_dentry); ++ goto out; /* success */ ++ } ++ ++ inode = d_inode(dentry); ++ AuDebugOn(bindex < au_ibtop(inode)); ++ AuDebugOn(au_ibbot(inode) < bindex); ++ h_inode = au_h_iptr(inode, bindex); ++ h_dentry = d_find_alias(h_inode); ++ if (h_dentry) { ++ if (!IS_ERR(h_dentry)) { ++ if (!au_d_linkable(h_dentry)) ++ goto out; /* success */ ++ dput(h_dentry); ++ } else ++ goto out; ++ } ++ ++ if (au_opt_test(au_mntflags(dentry->d_sb), PLINK)) { ++ h_dentry = au_plink_lkup(inode, bindex); ++ AuDebugOn(!h_dentry); ++ if (!IS_ERR(h_dentry)) { ++ if (!au_d_hashed_positive(h_dentry)) ++ goto out; /* success */ ++ dput(h_dentry); ++ h_dentry = NULL; ++ } ++ } ++ ++out: ++ AuDbgDentry(h_dentry); ++ return h_dentry; ++} ++ ++aufs_bindex_t au_dbtail(struct dentry *dentry) ++{ ++ aufs_bindex_t bbot, bwh; ++ ++ bbot = au_dbbot(dentry); ++ if (0 <= bbot) { ++ bwh = au_dbwh(dentry); ++ if (!bwh) ++ return bwh; ++ if (0 < bwh && bwh < bbot) ++ return bwh - 1; ++ } ++ return bbot; ++} ++ ++aufs_bindex_t au_dbtaildir(struct dentry *dentry) ++{ ++ aufs_bindex_t bbot, bopq; ++ ++ bbot = au_dbtail(dentry); ++ if (0 <= bbot) { ++ bopq = au_dbdiropq(dentry); ++ if (0 <= bopq && bopq < bbot) ++ bbot = bopq; ++ } ++ return bbot; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_set_h_dptr(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_dentry) ++{ ++ struct au_dinfo *dinfo; ++ struct au_hdentry *hd; ++ struct au_branch *br; ++ ++ DiMustWriteLock(dentry); ++ ++ dinfo = au_di(dentry); ++ hd = au_hdentry(dinfo, bindex); ++ au_hdput(hd); ++ hd->hd_dentry = h_dentry; ++ if (h_dentry) { ++ br = au_sbr(dentry->d_sb, bindex); ++ hd->hd_id = br->br_id; ++ } ++} ++ ++int au_dbrange_test(struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t btop, bbot; ++ ++ err = 0; ++ btop = au_dbtop(dentry); ++ bbot = au_dbbot(dentry); ++ if (btop >= 0) ++ AuDebugOn(bbot < 0 && btop > bbot); ++ else { ++ err = -EIO; ++ AuDebugOn(bbot >= 0); ++ } ++ ++ return err; ++} ++ ++int au_digen_test(struct dentry *dentry, unsigned int sigen) ++{ ++ int err; ++ ++ err = 0; ++ if (unlikely(au_digen(dentry) != sigen ++ || au_iigen_test(d_inode(dentry), sigen))) ++ err = -EIO; ++ ++ return err; ++} ++ ++void au_update_digen(struct dentry *dentry) ++{ ++ atomic_set(&au_di(dentry)->di_generation, au_sigen(dentry->d_sb)); ++ /* smp_mb(); */ /* atomic_set */ ++} ++ ++void au_update_dbrange(struct dentry *dentry, int do_put_zero) ++{ ++ struct au_dinfo *dinfo; ++ struct dentry *h_d; ++ struct au_hdentry *hdp; ++ aufs_bindex_t bindex, bbot; ++ ++ DiMustWriteLock(dentry); ++ ++ dinfo = au_di(dentry); ++ if (!dinfo || dinfo->di_btop < 0) ++ return; ++ ++ if (do_put_zero) { ++ bbot = dinfo->di_bbot; ++ bindex = dinfo->di_btop; ++ hdp = au_hdentry(dinfo, bindex); ++ for (; bindex <= bbot; bindex++, hdp++) { ++ h_d = hdp->hd_dentry; ++ if (h_d && d_is_negative(h_d)) ++ au_set_h_dptr(dentry, bindex, NULL); ++ } ++ } ++ ++ dinfo->di_btop = 0; ++ hdp = au_hdentry(dinfo, dinfo->di_btop); ++ for (; dinfo->di_btop <= dinfo->di_bbot; dinfo->di_btop++, hdp++) ++ if (hdp->hd_dentry) ++ break; ++ if (dinfo->di_btop > dinfo->di_bbot) { ++ dinfo->di_btop = -1; ++ dinfo->di_bbot = -1; ++ return; ++ } ++ ++ hdp = au_hdentry(dinfo, dinfo->di_bbot); ++ for (; dinfo->di_bbot >= 0; dinfo->di_bbot--, hdp--) ++ if (hdp->hd_dentry) ++ break; ++ AuDebugOn(dinfo->di_btop > dinfo->di_bbot || dinfo->di_bbot < 0); ++} ++ ++void au_update_dbtop(struct dentry *dentry) ++{ ++ aufs_bindex_t bindex, bbot; ++ struct dentry *h_dentry; ++ ++ bbot = au_dbbot(dentry); ++ for (bindex = au_dbtop(dentry); bindex <= bbot; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ if (d_is_positive(h_dentry)) { ++ au_set_dbtop(dentry, bindex); ++ return; ++ } ++ au_set_h_dptr(dentry, bindex, NULL); ++ } ++} ++ ++void au_update_dbbot(struct dentry *dentry) ++{ ++ aufs_bindex_t bindex, btop; ++ struct dentry *h_dentry; ++ ++ btop = au_dbtop(dentry); ++ for (bindex = au_dbbot(dentry); bindex >= btop; bindex--) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ if (d_is_positive(h_dentry)) { ++ au_set_dbbot(dentry, bindex); ++ return; ++ } ++ au_set_h_dptr(dentry, bindex, NULL); ++ } ++} ++ ++int au_find_dbindex(struct dentry *dentry, struct dentry *h_dentry) ++{ ++ aufs_bindex_t bindex, bbot; ++ ++ bbot = au_dbbot(dentry); ++ for (bindex = au_dbtop(dentry); bindex <= bbot; bindex++) ++ if (au_h_dptr(dentry, bindex) == h_dentry) ++ return bindex; ++ return -1; ++} +diff --git a/fs/aufs/dir.c b/fs/aufs/dir.c +new file mode 100644 +index 000000000000..44adae19efb1 +--- /dev/null ++++ b/fs/aufs/dir.c +@@ -0,0 +1,750 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * directory operations ++ */ ++ ++#include ++#include ++#include "aufs.h" ++ ++void au_add_nlink(struct inode *dir, struct inode *h_dir) ++{ ++ unsigned int nlink; ++ ++ AuDebugOn(!S_ISDIR(dir->i_mode) || !S_ISDIR(h_dir->i_mode)); ++ ++ nlink = dir->i_nlink; ++ nlink += h_dir->i_nlink - 2; ++ if (h_dir->i_nlink < 2) ++ nlink += 2; ++ smp_mb(); /* for i_nlink */ ++ /* 0 can happen in revaliding */ ++ set_nlink(dir, nlink); ++} ++ ++void au_sub_nlink(struct inode *dir, struct inode *h_dir) ++{ ++ unsigned int nlink; ++ ++ AuDebugOn(!S_ISDIR(dir->i_mode) || !S_ISDIR(h_dir->i_mode)); ++ ++ nlink = dir->i_nlink; ++ nlink -= h_dir->i_nlink - 2; ++ if (h_dir->i_nlink < 2) ++ nlink -= 2; ++ smp_mb(); /* for i_nlink */ ++ /* nlink == 0 means the branch-fs is broken */ ++ set_nlink(dir, nlink); ++} ++ ++loff_t au_dir_size(struct file *file, struct dentry *dentry) ++{ ++ loff_t sz; ++ aufs_bindex_t bindex, bbot; ++ struct file *h_file; ++ struct dentry *h_dentry; ++ ++ sz = 0; ++ if (file) { ++ AuDebugOn(!d_is_dir(file->f_path.dentry)); ++ ++ bbot = au_fbbot_dir(file); ++ for (bindex = au_fbtop(file); ++ bindex <= bbot && sz < KMALLOC_MAX_SIZE; ++ bindex++) { ++ h_file = au_hf_dir(file, bindex); ++ if (h_file && file_inode(h_file)) ++ sz += vfsub_f_size_read(h_file); ++ } ++ } else { ++ AuDebugOn(!dentry); ++ AuDebugOn(!d_is_dir(dentry)); ++ ++ bbot = au_dbtaildir(dentry); ++ for (bindex = au_dbtop(dentry); ++ bindex <= bbot && sz < KMALLOC_MAX_SIZE; ++ bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry && d_is_positive(h_dentry)) ++ sz += i_size_read(d_inode(h_dentry)); ++ } ++ } ++ if (sz < KMALLOC_MAX_SIZE) ++ sz = roundup_pow_of_two(sz); ++ if (sz > KMALLOC_MAX_SIZE) ++ sz = KMALLOC_MAX_SIZE; ++ else if (sz < NAME_MAX) { ++ BUILD_BUG_ON(AUFS_RDBLK_DEF < NAME_MAX); ++ sz = AUFS_RDBLK_DEF; ++ } ++ return sz; ++} ++ ++struct au_dir_ts_arg { ++ struct dentry *dentry; ++ aufs_bindex_t brid; ++}; ++ ++static void au_do_dir_ts(void *arg) ++{ ++ struct au_dir_ts_arg *a = arg; ++ struct au_dtime dt; ++ struct path h_path; ++ struct inode *dir, *h_dir; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_hinode *hdir; ++ int err; ++ aufs_bindex_t btop, bindex; ++ ++ sb = a->dentry->d_sb; ++ if (d_really_is_negative(a->dentry)) ++ goto out; ++ /* no dir->i_mutex lock */ ++ aufs_read_lock(a->dentry, AuLock_DW); /* noflush */ ++ ++ dir = d_inode(a->dentry); ++ btop = au_ibtop(dir); ++ bindex = au_br_index(sb, a->brid); ++ if (bindex < btop) ++ goto out_unlock; ++ ++ br = au_sbr(sb, bindex); ++ h_path.dentry = au_h_dptr(a->dentry, bindex); ++ if (!h_path.dentry) ++ goto out_unlock; ++ h_path.mnt = au_br_mnt(br); ++ au_dtime_store(&dt, a->dentry, &h_path); ++ ++ br = au_sbr(sb, btop); ++ if (!au_br_writable(br->br_perm)) ++ goto out_unlock; ++ h_path.dentry = au_h_dptr(a->dentry, btop); ++ h_path.mnt = au_br_mnt(br); ++ err = vfsub_mnt_want_write(h_path.mnt); ++ if (err) ++ goto out_unlock; ++ hdir = au_hi(dir, btop); ++ au_hn_inode_lock_nested(hdir, AuLsc_I_PARENT); ++ h_dir = au_h_iptr(dir, btop); ++ if (h_dir->i_nlink ++ && timespec64_compare(&h_dir->i_mtime, &dt.dt_mtime) < 0) { ++ dt.dt_h_path = h_path; ++ au_dtime_revert(&dt); ++ } ++ au_hn_inode_unlock(hdir); ++ vfsub_mnt_drop_write(h_path.mnt); ++ au_cpup_attr_timesizes(dir); ++ ++out_unlock: ++ aufs_read_unlock(a->dentry, AuLock_DW); ++out: ++ dput(a->dentry); ++ au_nwt_done(&au_sbi(sb)->si_nowait); ++ au_kfree_try_rcu(arg); ++} ++ ++void au_dir_ts(struct inode *dir, aufs_bindex_t bindex) ++{ ++ int perm, wkq_err; ++ aufs_bindex_t btop; ++ struct au_dir_ts_arg *arg; ++ struct dentry *dentry; ++ struct super_block *sb; ++ ++ IMustLock(dir); ++ ++ dentry = d_find_any_alias(dir); ++ AuDebugOn(!dentry); ++ sb = dentry->d_sb; ++ btop = au_ibtop(dir); ++ if (btop == bindex) { ++ au_cpup_attr_timesizes(dir); ++ goto out; ++ } ++ ++ perm = au_sbr_perm(sb, btop); ++ if (!au_br_writable(perm)) ++ goto out; ++ ++ arg = kmalloc(sizeof(*arg), GFP_NOFS); ++ if (!arg) ++ goto out; ++ ++ arg->dentry = dget(dentry); /* will be dput-ted by au_do_dir_ts() */ ++ arg->brid = au_sbr_id(sb, bindex); ++ wkq_err = au_wkq_nowait(au_do_dir_ts, arg, sb, /*flags*/0); ++ if (unlikely(wkq_err)) { ++ pr_err("wkq %d\n", wkq_err); ++ dput(dentry); ++ au_kfree_try_rcu(arg); ++ } ++ ++out: ++ dput(dentry); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int reopen_dir(struct file *file) ++{ ++ int err; ++ unsigned int flags; ++ aufs_bindex_t bindex, btail, btop; ++ struct dentry *dentry, *h_dentry; ++ struct file *h_file; ++ ++ /* open all lower dirs */ ++ dentry = file->f_path.dentry; ++ btop = au_dbtop(dentry); ++ for (bindex = au_fbtop(file); bindex < btop; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ au_set_fbtop(file, btop); ++ ++ btail = au_dbtaildir(dentry); ++ for (bindex = au_fbbot_dir(file); btail < bindex; bindex--) ++ au_set_h_fptr(file, bindex, NULL); ++ au_set_fbbot_dir(file, btail); ++ ++ flags = vfsub_file_flags(file); ++ for (bindex = btop; bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ h_file = au_hf_dir(file, bindex); ++ if (h_file) ++ continue; ++ ++ h_file = au_h_open(dentry, bindex, flags, file, /*force_wr*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; /* close all? */ ++ au_set_h_fptr(file, bindex, h_file); ++ } ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ err = 0; ++ ++out: ++ return err; ++} ++ ++static int do_open_dir(struct file *file, int flags, struct file *h_file) ++{ ++ int err; ++ aufs_bindex_t bindex, btail; ++ struct dentry *dentry, *h_dentry; ++ struct vfsmount *mnt; ++ ++ FiMustWriteLock(file); ++ AuDebugOn(h_file); ++ ++ err = 0; ++ mnt = file->f_path.mnt; ++ dentry = file->f_path.dentry; ++ file->f_version = inode_query_iversion(d_inode(dentry)); ++ bindex = au_dbtop(dentry); ++ au_set_fbtop(file, bindex); ++ btail = au_dbtaildir(dentry); ++ au_set_fbbot_dir(file, btail); ++ for (; !err && bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ ++ err = vfsub_test_mntns(mnt, h_dentry->d_sb); ++ if (unlikely(err)) ++ break; ++ h_file = au_h_open(dentry, bindex, flags, file, /*force_wr*/0); ++ if (IS_ERR(h_file)) { ++ err = PTR_ERR(h_file); ++ break; ++ } ++ au_set_h_fptr(file, bindex, h_file); ++ } ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ if (!err) ++ return 0; /* success */ ++ ++ /* close all */ ++ for (bindex = au_fbtop(file); bindex <= btail; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ au_set_fbtop(file, -1); ++ au_set_fbbot_dir(file, -1); ++ ++ return err; ++} ++ ++static int aufs_open_dir(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ int err; ++ struct super_block *sb; ++ struct au_fidir *fidir; ++ ++ err = -ENOMEM; ++ sb = file->f_path.dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ fidir = au_fidir_alloc(sb); ++ if (fidir) { ++ struct au_do_open_args args = { ++ .open = do_open_dir, ++ .fidir = fidir ++ }; ++ err = au_do_open(file, &args); ++ if (unlikely(err)) ++ au_kfree_rcu(fidir); ++ } ++ si_read_unlock(sb); ++ return err; ++} ++ ++static int aufs_release_dir(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ struct au_vdir *vdir_cache; ++ struct au_finfo *finfo; ++ struct au_fidir *fidir; ++ struct au_hfile *hf; ++ aufs_bindex_t bindex, bbot; ++ ++ finfo = au_fi(file); ++ fidir = finfo->fi_hdir; ++ if (fidir) { ++ au_hbl_del(&finfo->fi_hlist, ++ &au_sbi(file->f_path.dentry->d_sb)->si_files); ++ vdir_cache = fidir->fd_vdir_cache; /* lock-free */ ++ if (vdir_cache) ++ au_vdir_free(vdir_cache); ++ ++ bindex = finfo->fi_btop; ++ if (bindex >= 0) { ++ hf = fidir->fd_hfile + bindex; ++ /* ++ * calls fput() instead of filp_close(), ++ * since no dnotify or lock for the lower file. ++ */ ++ bbot = fidir->fd_bbot; ++ for (; bindex <= bbot; bindex++, hf++) ++ if (hf->hf_file) ++ au_hfput(hf, /*execed*/0); ++ } ++ au_kfree_rcu(fidir); ++ finfo->fi_hdir = NULL; ++ } ++ au_finfo_fin(file); ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_do_flush_dir(struct file *file, fl_owner_t id) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ struct file *h_file; ++ ++ err = 0; ++ bbot = au_fbbot_dir(file); ++ for (bindex = au_fbtop(file); !err && bindex <= bbot; bindex++) { ++ h_file = au_hf_dir(file, bindex); ++ if (h_file) ++ err = vfsub_flush(h_file, id); ++ } ++ return err; ++} ++ ++static int aufs_flush_dir(struct file *file, fl_owner_t id) ++{ ++ return au_do_flush(file, id, au_do_flush_dir); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_do_fsync_dir_no_file(struct dentry *dentry, int datasync) ++{ ++ int err; ++ aufs_bindex_t bbot, bindex; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ err = 0; ++ sb = dentry->d_sb; ++ inode = d_inode(dentry); ++ IMustLock(inode); ++ bbot = au_dbbot(dentry); ++ for (bindex = au_dbtop(dentry); !err && bindex <= bbot; bindex++) { ++ struct path h_path; ++ ++ if (au_test_ro(sb, bindex, inode)) ++ continue; ++ h_path.dentry = au_h_dptr(dentry, bindex); ++ if (!h_path.dentry) ++ continue; ++ ++ h_path.mnt = au_sbr_mnt(sb, bindex); ++ err = vfsub_fsync(NULL, &h_path, datasync); ++ } ++ ++ return err; ++} ++ ++static int au_do_fsync_dir(struct file *file, int datasync) ++{ ++ int err; ++ aufs_bindex_t bbot, bindex; ++ struct file *h_file; ++ struct super_block *sb; ++ struct inode *inode; ++ ++ err = au_reval_and_lock_fdi(file, reopen_dir, /*wlock*/1, /*fi_lsc*/0); ++ if (unlikely(err)) ++ goto out; ++ ++ inode = file_inode(file); ++ sb = inode->i_sb; ++ bbot = au_fbbot_dir(file); ++ for (bindex = au_fbtop(file); !err && bindex <= bbot; bindex++) { ++ h_file = au_hf_dir(file, bindex); ++ if (!h_file || au_test_ro(sb, bindex, inode)) ++ continue; ++ ++ err = vfsub_fsync(h_file, &h_file->f_path, datasync); ++ } ++ ++out: ++ return err; ++} ++ ++/* ++ * @file may be NULL ++ */ ++static int aufs_fsync_dir(struct file *file, loff_t start, loff_t end, ++ int datasync) ++{ ++ int err; ++ struct dentry *dentry; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ err = 0; ++ dentry = file->f_path.dentry; ++ inode = d_inode(dentry); ++ inode_lock(inode); ++ sb = dentry->d_sb; ++ si_noflush_read_lock(sb); ++ if (file) ++ err = au_do_fsync_dir(file, datasync); ++ else { ++ di_write_lock_child(dentry); ++ err = au_do_fsync_dir_no_file(dentry, datasync); ++ } ++ au_cpup_attr_timesizes(inode); ++ di_write_unlock(dentry); ++ if (file) ++ fi_write_unlock(file); ++ ++ si_read_unlock(sb); ++ inode_unlock(inode); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_iterate_shared(struct file *file, struct dir_context *ctx) ++{ ++ int err; ++ struct dentry *dentry; ++ struct inode *inode, *h_inode; ++ struct super_block *sb; ++ ++ AuDbg("%pD, ctx{%ps, %llu}\n", file, ctx->actor, ctx->pos); ++ ++ dentry = file->f_path.dentry; ++ inode = d_inode(dentry); ++ IMustLock(inode); ++ ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_reval_and_lock_fdi(file, reopen_dir, /*wlock*/1, /*fi_lsc*/0); ++ if (unlikely(err)) ++ goto out; ++ err = au_alive_dir(dentry); ++ if (!err) ++ err = au_vdir_init(file); ++ di_downgrade_lock(dentry, AuLock_IR); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ h_inode = au_h_iptr(inode, au_ibtop(inode)); ++ if (!au_test_nfsd()) { ++ err = au_vdir_fill_de(file, ctx); ++ fsstack_copy_attr_atime(inode, h_inode); ++ } else { ++ /* ++ * nfsd filldir may call lookup_one_len(), vfs_getattr(), ++ * encode_fh() and others. ++ */ ++ atomic_inc(&h_inode->i_count); ++ di_read_unlock(dentry, AuLock_IR); ++ si_read_unlock(sb); ++ err = au_vdir_fill_de(file, ctx); ++ fsstack_copy_attr_atime(inode, h_inode); ++ fi_write_unlock(file); ++ iput(h_inode); ++ ++ AuTraceErr(err); ++ return err; ++ } ++ ++out_unlock: ++ di_read_unlock(dentry, AuLock_IR); ++ fi_write_unlock(file); ++out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define AuTestEmpty_WHONLY 1 ++#define AuTestEmpty_CALLED (1 << 1) ++#define AuTestEmpty_SHWH (1 << 2) ++#define au_ftest_testempty(flags, name) ((flags) & AuTestEmpty_##name) ++#define au_fset_testempty(flags, name) \ ++ do { (flags) |= AuTestEmpty_##name; } while (0) ++#define au_fclr_testempty(flags, name) \ ++ do { (flags) &= ~AuTestEmpty_##name; } while (0) ++ ++#ifndef CONFIG_AUFS_SHWH ++#undef AuTestEmpty_SHWH ++#define AuTestEmpty_SHWH 0 ++#endif ++ ++struct test_empty_arg { ++ struct dir_context ctx; ++ struct au_nhash *whlist; ++ unsigned int flags; ++ int err; ++ aufs_bindex_t bindex; ++}; ++ ++static int test_empty_cb(struct dir_context *ctx, const char *__name, ++ int namelen, loff_t offset __maybe_unused, u64 ino, ++ unsigned int d_type) ++{ ++ struct test_empty_arg *arg = container_of(ctx, struct test_empty_arg, ++ ctx); ++ char *name = (void *)__name; ++ ++ arg->err = 0; ++ au_fset_testempty(arg->flags, CALLED); ++ /* smp_mb(); */ ++ if (name[0] == '.' ++ && (namelen == 1 || (name[1] == '.' && namelen == 2))) ++ goto out; /* success */ ++ ++ if (namelen <= AUFS_WH_PFX_LEN ++ || memcmp(name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) { ++ if (au_ftest_testempty(arg->flags, WHONLY) ++ && !au_nhash_test_known_wh(arg->whlist, name, namelen)) ++ arg->err = -ENOTEMPTY; ++ goto out; ++ } ++ ++ name += AUFS_WH_PFX_LEN; ++ namelen -= AUFS_WH_PFX_LEN; ++ if (!au_nhash_test_known_wh(arg->whlist, name, namelen)) ++ arg->err = au_nhash_append_wh ++ (arg->whlist, name, namelen, ino, d_type, arg->bindex, ++ au_ftest_testempty(arg->flags, SHWH)); ++ ++out: ++ /* smp_mb(); */ ++ AuTraceErr(arg->err); ++ return arg->err; ++} ++ ++static int do_test_empty(struct dentry *dentry, struct test_empty_arg *arg) ++{ ++ int err; ++ struct file *h_file; ++ struct au_branch *br; ++ ++ h_file = au_h_open(dentry, arg->bindex, ++ O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_LARGEFILE, ++ /*file*/NULL, /*force_wr*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ err = 0; ++ if (!au_opt_test(au_mntflags(dentry->d_sb), UDBA_NONE) ++ && !file_inode(h_file)->i_nlink) ++ goto out_put; ++ ++ do { ++ arg->err = 0; ++ au_fclr_testempty(arg->flags, CALLED); ++ /* smp_mb(); */ ++ err = vfsub_iterate_dir(h_file, &arg->ctx); ++ if (err >= 0) ++ err = arg->err; ++ } while (!err && au_ftest_testempty(arg->flags, CALLED)); ++ ++out_put: ++ fput(h_file); ++ br = au_sbr(dentry->d_sb, arg->bindex); ++ au_lcnt_dec(&br->br_nfiles); ++out: ++ return err; ++} ++ ++struct do_test_empty_args { ++ int *errp; ++ struct dentry *dentry; ++ struct test_empty_arg *arg; ++}; ++ ++static void call_do_test_empty(void *args) ++{ ++ struct do_test_empty_args *a = args; ++ *a->errp = do_test_empty(a->dentry, a->arg); ++} ++ ++static int sio_test_empty(struct dentry *dentry, struct test_empty_arg *arg) ++{ ++ int err, wkq_err; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ ++ h_dentry = au_h_dptr(dentry, arg->bindex); ++ h_inode = d_inode(h_dentry); ++ /* todo: i_mode changes anytime? */ ++ inode_lock_shared_nested(h_inode, AuLsc_I_CHILD); ++ err = au_test_h_perm_sio(h_inode, MAY_EXEC | MAY_READ); ++ inode_unlock_shared(h_inode); ++ if (!err) ++ err = do_test_empty(dentry, arg); ++ else { ++ struct do_test_empty_args args = { ++ .errp = &err, ++ .dentry = dentry, ++ .arg = arg ++ }; ++ unsigned int flags = arg->flags; ++ ++ wkq_err = au_wkq_wait(call_do_test_empty, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ arg->flags = flags; ++ } ++ ++ return err; ++} ++ ++int au_test_empty_lower(struct dentry *dentry) ++{ ++ int err; ++ unsigned int rdhash; ++ aufs_bindex_t bindex, btop, btail; ++ struct au_nhash whlist; ++ struct test_empty_arg arg = { ++ .ctx = { ++ .actor = test_empty_cb ++ } ++ }; ++ int (*test_empty)(struct dentry *dentry, struct test_empty_arg *arg); ++ ++ SiMustAnyLock(dentry->d_sb); ++ ++ rdhash = au_sbi(dentry->d_sb)->si_rdhash; ++ if (!rdhash) ++ rdhash = au_rdhash_est(au_dir_size(/*file*/NULL, dentry)); ++ err = au_nhash_alloc(&whlist, rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ ++ arg.flags = 0; ++ arg.whlist = &whlist; ++ btop = au_dbtop(dentry); ++ if (au_opt_test(au_mntflags(dentry->d_sb), SHWH)) ++ au_fset_testempty(arg.flags, SHWH); ++ test_empty = do_test_empty; ++ if (au_opt_test(au_mntflags(dentry->d_sb), DIRPERM1)) ++ test_empty = sio_test_empty; ++ arg.bindex = btop; ++ err = test_empty(dentry, &arg); ++ if (unlikely(err)) ++ goto out_whlist; ++ ++ au_fset_testempty(arg.flags, WHONLY); ++ btail = au_dbtaildir(dentry); ++ for (bindex = btop + 1; !err && bindex <= btail; bindex++) { ++ struct dentry *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry && d_is_positive(h_dentry)) { ++ arg.bindex = bindex; ++ err = test_empty(dentry, &arg); ++ } ++ } ++ ++out_whlist: ++ au_nhash_wh_free(&whlist); ++out: ++ return err; ++} ++ ++int au_test_empty(struct dentry *dentry, struct au_nhash *whlist) ++{ ++ int err; ++ struct test_empty_arg arg = { ++ .ctx = { ++ .actor = test_empty_cb ++ } ++ }; ++ aufs_bindex_t bindex, btail; ++ ++ err = 0; ++ arg.whlist = whlist; ++ arg.flags = AuTestEmpty_WHONLY; ++ if (au_opt_test(au_mntflags(dentry->d_sb), SHWH)) ++ au_fset_testempty(arg.flags, SHWH); ++ btail = au_dbtaildir(dentry); ++ for (bindex = au_dbtop(dentry); !err && bindex <= btail; bindex++) { ++ struct dentry *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry && d_is_positive(h_dentry)) { ++ arg.bindex = bindex; ++ err = sio_test_empty(dentry, &arg); ++ } ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++const struct file_operations aufs_dir_fop = { ++ .owner = THIS_MODULE, ++ .llseek = default_llseek, ++ .read = generic_read_dir, ++ .iterate_shared = aufs_iterate_shared, ++ .unlocked_ioctl = aufs_ioctl_dir, ++#ifdef CONFIG_COMPAT ++ .compat_ioctl = aufs_compat_ioctl_dir, ++#endif ++ .open = aufs_open_dir, ++ .release = aufs_release_dir, ++ .flush = aufs_flush_dir, ++ .fsync = aufs_fsync_dir ++}; +diff --git a/fs/aufs/dir.h b/fs/aufs/dir.h +new file mode 100644 +index 000000000000..75fad78d2278 +--- /dev/null ++++ b/fs/aufs/dir.h +@@ -0,0 +1,121 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * directory operations ++ */ ++ ++#ifndef __AUFS_DIR_H__ ++#define __AUFS_DIR_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* need to be faster and smaller */ ++ ++struct au_nhash { ++ unsigned int nh_num; ++ struct hlist_head *nh_head; ++}; ++ ++struct au_vdir_destr { ++ unsigned char len; ++ unsigned char name[]; ++} __packed; ++ ++struct au_vdir_dehstr { ++ struct hlist_node hash; ++ struct au_vdir_destr *str; ++ struct rcu_head rcu; ++} ____cacheline_aligned_in_smp; ++ ++struct au_vdir_de { ++ ino_t de_ino; ++ unsigned char de_type; ++ /* caution: packed */ ++ struct au_vdir_destr de_str; ++} __packed; ++ ++struct au_vdir_wh { ++ struct hlist_node wh_hash; ++#ifdef CONFIG_AUFS_SHWH ++ ino_t wh_ino; ++ aufs_bindex_t wh_bindex; ++ unsigned char wh_type; ++#else ++ aufs_bindex_t wh_bindex; ++#endif ++ /* caution: packed */ ++ struct au_vdir_destr wh_str; ++} __packed; ++ ++union au_vdir_deblk_p { ++ unsigned char *deblk; ++ struct au_vdir_de *de; ++}; ++ ++struct au_vdir { ++ unsigned char **vd_deblk; ++ unsigned long vd_nblk; ++ struct { ++ unsigned long ul; ++ union au_vdir_deblk_p p; ++ } vd_last; ++ ++ u64 vd_version; ++ unsigned int vd_deblk_sz; ++ unsigned long vd_jiffy; ++ struct rcu_head rcu; ++} ____cacheline_aligned_in_smp; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dir.c */ ++extern const struct file_operations aufs_dir_fop; ++void au_add_nlink(struct inode *dir, struct inode *h_dir); ++void au_sub_nlink(struct inode *dir, struct inode *h_dir); ++loff_t au_dir_size(struct file *file, struct dentry *dentry); ++void au_dir_ts(struct inode *dir, aufs_bindex_t bsrc); ++int au_test_empty_lower(struct dentry *dentry); ++int au_test_empty(struct dentry *dentry, struct au_nhash *whlist); ++ ++/* vdir.c */ ++unsigned int au_rdhash_est(loff_t sz); ++int au_nhash_alloc(struct au_nhash *nhash, unsigned int num_hash, gfp_t gfp); ++void au_nhash_wh_free(struct au_nhash *whlist); ++int au_nhash_test_longer_wh(struct au_nhash *whlist, aufs_bindex_t btgt, ++ int limit); ++int au_nhash_test_known_wh(struct au_nhash *whlist, char *name, int nlen); ++int au_nhash_append_wh(struct au_nhash *whlist, char *name, int nlen, ino_t ino, ++ unsigned int d_type, aufs_bindex_t bindex, ++ unsigned char shwh); ++void au_vdir_free(struct au_vdir *vdir); ++int au_vdir_init(struct file *file); ++int au_vdir_fill_de(struct file *file, struct dir_context *ctx); ++ ++/* ioctl.c */ ++long aufs_ioctl_dir(struct file *file, unsigned int cmd, unsigned long arg); ++ ++#ifdef CONFIG_AUFS_RDU ++/* rdu.c */ ++long au_rdu_ioctl(struct file *file, unsigned int cmd, unsigned long arg); ++#ifdef CONFIG_COMPAT ++long au_rdu_compat_ioctl(struct file *file, unsigned int cmd, ++ unsigned long arg); ++#endif ++#else ++AuStub(long, au_rdu_ioctl, return -EINVAL, struct file *file, ++ unsigned int cmd, unsigned long arg) ++#ifdef CONFIG_COMPAT ++AuStub(long, au_rdu_compat_ioctl, return -EINVAL, struct file *file, ++ unsigned int cmd, unsigned long arg) ++#endif ++#endif ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DIR_H__ */ +diff --git a/fs/aufs/dirren.c b/fs/aufs/dirren.c +new file mode 100644 +index 000000000000..12b56c47f2dd +--- /dev/null ++++ b/fs/aufs/dirren.c +@@ -0,0 +1,1303 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2017-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * special handling in renaming a directory ++ * in order to support looking-up the before-renamed name on the lower readonly ++ * branches ++ */ ++ ++#include ++#include "aufs.h" ++ ++static void au_dr_hino_del(struct au_dr_br *dr, struct au_dr_hino *ent) ++{ ++ int idx; ++ ++ idx = au_dr_ihash(ent->dr_h_ino); ++ au_hbl_del(&ent->dr_hnode, dr->dr_h_ino + idx); ++} ++ ++static int au_dr_hino_test_empty(struct au_dr_br *dr) ++{ ++ int ret, i; ++ struct hlist_bl_head *hbl; ++ ++ ret = 1; ++ for (i = 0; ret && i < AuDirren_NHASH; i++) { ++ hbl = dr->dr_h_ino + i; ++ hlist_bl_lock(hbl); ++ ret &= hlist_bl_empty(hbl); ++ hlist_bl_unlock(hbl); ++ } ++ ++ return ret; ++} ++ ++static struct au_dr_hino *au_dr_hino_find(struct au_dr_br *dr, ino_t ino) ++{ ++ struct au_dr_hino *found, *ent; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ int idx; ++ ++ found = NULL; ++ idx = au_dr_ihash(ino); ++ hbl = dr->dr_h_ino + idx; ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(ent, pos, hbl, dr_hnode) ++ if (ent->dr_h_ino == ino) { ++ found = ent; ++ break; ++ } ++ hlist_bl_unlock(hbl); ++ ++ return found; ++} ++ ++int au_dr_hino_test_add(struct au_dr_br *dr, ino_t ino, ++ struct au_dr_hino *add_ent) ++{ ++ int found, idx; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ struct au_dr_hino *ent; ++ ++ found = 0; ++ idx = au_dr_ihash(ino); ++ hbl = dr->dr_h_ino + idx; ++#if 0 /* debug print */ ++ { ++ struct hlist_bl_node *tmp; ++ ++ hlist_bl_for_each_entry_safe(ent, pos, tmp, hbl, dr_hnode) ++ AuDbg("hi%llu\n", (unsigned long long)ent->dr_h_ino); ++ } ++#endif ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(ent, pos, hbl, dr_hnode) ++ if (ent->dr_h_ino == ino) { ++ found = 1; ++ break; ++ } ++ if (!found && add_ent) ++ hlist_bl_add_head(&add_ent->dr_hnode, hbl); ++ hlist_bl_unlock(hbl); ++ ++ if (!found && add_ent) ++ AuDbg("i%llu added\n", (unsigned long long)add_ent->dr_h_ino); ++ ++ return found; ++} ++ ++void au_dr_hino_free(struct au_dr_br *dr) ++{ ++ int i; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos, *tmp; ++ struct au_dr_hino *ent; ++ ++ /* SiMustWriteLock(sb); */ ++ ++ for (i = 0; i < AuDirren_NHASH; i++) { ++ hbl = dr->dr_h_ino + i; ++ /* no spinlock since sbinfo must be write-locked */ ++ hlist_bl_for_each_entry_safe(ent, pos, tmp, hbl, dr_hnode) ++ au_kfree_rcu(ent); ++ INIT_HLIST_BL_HEAD(hbl); ++ } ++} ++ ++/* returns the number of inodes or an error */ ++static int au_dr_hino_store(struct super_block *sb, struct au_branch *br, ++ struct file *hinofile) ++{ ++ int err, i; ++ ssize_t ssz; ++ loff_t pos, oldsize; ++ __be64 u64; ++ struct inode *hinoinode; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *n1, *n2; ++ struct au_dr_hino *ent; ++ ++ SiMustWriteLock(sb); ++ AuDebugOn(!au_br_writable(br->br_perm)); ++ ++ hinoinode = file_inode(hinofile); ++ oldsize = i_size_read(hinoinode); ++ ++ err = 0; ++ pos = 0; ++ hbl = br->br_dirren.dr_h_ino; ++ for (i = 0; !err && i < AuDirren_NHASH; i++, hbl++) { ++ /* no bit-lock since sbinfo must be write-locked */ ++ hlist_bl_for_each_entry_safe(ent, n1, n2, hbl, dr_hnode) { ++ AuDbg("hi%llu, %pD2\n", ++ (unsigned long long)ent->dr_h_ino, hinofile); ++ u64 = cpu_to_be64(ent->dr_h_ino); ++ ssz = vfsub_write_k(hinofile, &u64, sizeof(u64), &pos); ++ if (ssz == sizeof(u64)) ++ continue; ++ ++ /* write error */ ++ pr_err("ssz %zd, %pD2\n", ssz, hinofile); ++ err = -ENOSPC; ++ if (ssz < 0) ++ err = ssz; ++ break; ++ } ++ } ++ /* regardless the error */ ++ if (pos < oldsize) { ++ err = vfsub_trunc(&hinofile->f_path, pos, /*attr*/0, hinofile); ++ AuTraceErr(err); ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_dr_hino_load(struct au_dr_br *dr, struct file *hinofile) ++{ ++ int err, hidx; ++ ssize_t ssz; ++ size_t sz, n; ++ loff_t pos; ++ uint64_t u64; ++ struct au_dr_hino *ent; ++ struct inode *hinoinode; ++ struct hlist_bl_head *hbl; ++ ++ err = 0; ++ pos = 0; ++ hbl = dr->dr_h_ino; ++ hinoinode = file_inode(hinofile); ++ sz = i_size_read(hinoinode); ++ AuDebugOn(sz % sizeof(u64)); ++ n = sz / sizeof(u64); ++ while (n--) { ++ ssz = vfsub_read_k(hinofile, &u64, sizeof(u64), &pos); ++ if (unlikely(ssz != sizeof(u64))) { ++ pr_err("ssz %zd, %pD2\n", ssz, hinofile); ++ err = -EINVAL; ++ if (ssz < 0) ++ err = ssz; ++ goto out_free; ++ } ++ ++ ent = kmalloc(sizeof(*ent), GFP_NOFS); ++ if (!ent) { ++ err = -ENOMEM; ++ AuTraceErr(err); ++ goto out_free; ++ } ++ ent->dr_h_ino = be64_to_cpu((__force __be64)u64); ++ AuDbg("hi%llu, %pD2\n", ++ (unsigned long long)ent->dr_h_ino, hinofile); ++ hidx = au_dr_ihash(ent->dr_h_ino); ++ au_hbl_add(&ent->dr_hnode, hbl + hidx); ++ } ++ goto out; /* success */ ++ ++out_free: ++ au_dr_hino_free(dr); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ++ * @bindex/@br is a switch to distinguish whether suspending hnotify or not. ++ * @path is a switch to distinguish load and store. ++ */ ++static int au_dr_hino(struct super_block *sb, aufs_bindex_t bindex, ++ struct au_branch *br, const struct path *path) ++{ ++ int err, flags; ++ unsigned char load, suspend; ++ struct file *hinofile; ++ struct au_hinode *hdir; ++ struct inode *dir, *delegated; ++ struct path hinopath; ++ struct qstr hinoname = QSTR_INIT(AUFS_WH_DR_BRHINO, ++ sizeof(AUFS_WH_DR_BRHINO) - 1); ++ ++ AuDebugOn(bindex < 0 && !br); ++ AuDebugOn(bindex >= 0 && br); ++ ++ err = -EINVAL; ++ suspend = !br; ++ if (suspend) ++ br = au_sbr(sb, bindex); ++ load = !!path; ++ if (!load) { ++ path = &br->br_path; ++ AuDebugOn(!au_br_writable(br->br_perm)); ++ if (unlikely(!au_br_writable(br->br_perm))) ++ goto out; ++ } ++ ++ hdir = NULL; ++ if (suspend) { ++ dir = d_inode(sb->s_root); ++ hdir = au_hinode(au_ii(dir), bindex); ++ dir = hdir->hi_inode; ++ au_hn_inode_lock_nested(hdir, AuLsc_I_CHILD); ++ } else { ++ dir = d_inode(path->dentry); ++ inode_lock_nested(dir, AuLsc_I_CHILD); ++ } ++ hinopath.dentry = vfsub_lkup_one(&hinoname, path->dentry); ++ err = PTR_ERR(hinopath.dentry); ++ if (IS_ERR(hinopath.dentry)) ++ goto out_unlock; ++ ++ err = 0; ++ flags = O_RDONLY; ++ if (load) { ++ if (d_is_negative(hinopath.dentry)) ++ goto out_dput; /* success */ ++ } else { ++ if (au_dr_hino_test_empty(&br->br_dirren)) { ++ if (d_is_positive(hinopath.dentry)) { ++ delegated = NULL; ++ err = vfsub_unlink(dir, &hinopath, &delegated, ++ /*force*/0); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ pr_err("ignored err %d, %pd2\n", ++ err, hinopath.dentry); ++ if (unlikely(err == -EWOULDBLOCK)) ++ iput(delegated); ++ err = 0; ++ } ++ goto out_dput; ++ } else if (!d_is_positive(hinopath.dentry)) { ++ err = vfsub_create(dir, &hinopath, 0600, ++ /*want_excl*/false); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ goto out_dput; ++ } ++ flags = O_WRONLY; ++ } ++ hinopath.mnt = path->mnt; ++ hinofile = vfsub_dentry_open(&hinopath, flags); ++ if (suspend) ++ au_hn_inode_unlock(hdir); ++ else ++ inode_unlock(dir); ++ dput(hinopath.dentry); ++ AuTraceErrPtr(hinofile); ++ if (IS_ERR(hinofile)) { ++ err = PTR_ERR(hinofile); ++ goto out; ++ } ++ ++ if (load) ++ err = au_dr_hino_load(&br->br_dirren, hinofile); ++ else ++ err = au_dr_hino_store(sb, br, hinofile); ++ fput(hinofile); ++ goto out; ++ ++out_dput: ++ dput(hinopath.dentry); ++out_unlock: ++ if (suspend) ++ au_hn_inode_unlock(hdir); ++ else ++ inode_unlock(dir); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_dr_brid_init(struct au_dr_brid *brid, const struct path *path) ++{ ++ int err; ++ struct kstatfs kstfs; ++ dev_t dev; ++ struct dentry *dentry; ++ struct super_block *sb; ++ ++ err = vfs_statfs((void *)path, &kstfs); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ goto out; ++ ++ /* todo: support for UUID */ ++ ++ if (kstfs.f_fsid.val[0] || kstfs.f_fsid.val[1]) { ++ brid->type = AuBrid_FSID; ++ brid->fsid = kstfs.f_fsid; ++ } else { ++ dentry = path->dentry; ++ sb = dentry->d_sb; ++ dev = sb->s_dev; ++ if (dev) { ++ brid->type = AuBrid_DEV; ++ brid->dev = dev; ++ } ++ } ++ ++out: ++ return err; ++} ++ ++int au_dr_br_init(struct super_block *sb, struct au_branch *br, ++ const struct path *path) ++{ ++ int err, i; ++ struct au_dr_br *dr; ++ struct hlist_bl_head *hbl; ++ ++ dr = &br->br_dirren; ++ hbl = dr->dr_h_ino; ++ for (i = 0; i < AuDirren_NHASH; i++, hbl++) ++ INIT_HLIST_BL_HEAD(hbl); ++ ++ err = au_dr_brid_init(&dr->dr_brid, path); ++ if (unlikely(err)) ++ goto out; ++ ++ if (au_opt_test(au_mntflags(sb), DIRREN)) ++ err = au_dr_hino(sb, /*bindex*/-1, br, path); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_dr_br_fin(struct super_block *sb, struct au_branch *br) ++{ ++ int err; ++ ++ err = 0; ++ if (au_br_writable(br->br_perm)) ++ err = au_dr_hino(sb, /*bindex*/-1, br, /*path*/NULL); ++ if (!err) ++ au_dr_hino_free(&br->br_dirren); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_brid_str(struct au_dr_brid *brid, struct inode *h_inode, ++ char *buf, size_t sz) ++{ ++ int err; ++ unsigned int major, minor; ++ char *p; ++ ++ p = buf; ++ err = snprintf(p, sz, "%d_", brid->type); ++ AuDebugOn(err > sz); ++ p += err; ++ sz -= err; ++ switch (brid->type) { ++ case AuBrid_Unset: ++ return -EINVAL; ++ case AuBrid_UUID: ++ err = snprintf(p, sz, "%pU", brid->uuid.b); ++ break; ++ case AuBrid_FSID: ++ err = snprintf(p, sz, "%08x-%08x", ++ brid->fsid.val[0], brid->fsid.val[1]); ++ break; ++ case AuBrid_DEV: ++ major = MAJOR(brid->dev); ++ minor = MINOR(brid->dev); ++ if (major <= 0xff && minor <= 0xff) ++ err = snprintf(p, sz, "%02x%02x", major, minor); ++ else ++ err = snprintf(p, sz, "%03x:%05x", major, minor); ++ break; ++ } ++ AuDebugOn(err > sz); ++ p += err; ++ sz -= err; ++ err = snprintf(p, sz, "_%llu", (unsigned long long)h_inode->i_ino); ++ AuDebugOn(err > sz); ++ p += err; ++ sz -= err; ++ ++ return p - buf; ++} ++ ++static int au_drinfo_name(struct au_branch *br, char *name, int len) ++{ ++ int rlen; ++ struct dentry *br_dentry; ++ struct inode *br_inode; ++ ++ br_dentry = au_br_dentry(br); ++ br_inode = d_inode(br_dentry); ++ rlen = au_brid_str(&br->br_dirren.dr_brid, br_inode, name, len); ++ AuDebugOn(rlen >= AUFS_DIRREN_ENV_VAL_SZ); ++ AuDebugOn(rlen > len); ++ ++ return rlen; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * from the given @h_dentry, construct drinfo at @*fdata. ++ * when the size of @*fdata is not enough, reallocate and return new @fdata and ++ * @allocated. ++ */ ++static int au_drinfo_construct(struct au_drinfo_fdata **fdata, ++ struct dentry *h_dentry, ++ unsigned char *allocated) ++{ ++ int err, v; ++ struct au_drinfo_fdata *f, *p; ++ struct au_drinfo *drinfo; ++ struct inode *h_inode; ++ struct qstr *qname; ++ ++ err = 0; ++ f = *fdata; ++ h_inode = d_inode(h_dentry); ++ qname = &h_dentry->d_name; ++ drinfo = &f->drinfo; ++ drinfo->ino = (__force uint64_t)cpu_to_be64(h_inode->i_ino); ++ drinfo->oldnamelen = qname->len; ++ if (*allocated < sizeof(*f) + qname->len) { ++ v = roundup_pow_of_two(*allocated + qname->len); ++ p = au_krealloc(f, v, GFP_NOFS, /*may_shrink*/0); ++ if (unlikely(!p)) { ++ err = -ENOMEM; ++ AuTraceErr(err); ++ goto out; ++ } ++ f = p; ++ *fdata = f; ++ *allocated = v; ++ drinfo = &f->drinfo; ++ } ++ memcpy(drinfo->oldname, qname->name, qname->len); ++ AuDbg("i%llu, %.*s\n", ++ be64_to_cpu((__force __be64)drinfo->ino), drinfo->oldnamelen, ++ drinfo->oldname); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* callers have to free the return value */ ++static struct au_drinfo *au_drinfo_read_k(struct file *file, ino_t h_ino) ++{ ++ struct au_drinfo *ret, *drinfo; ++ struct au_drinfo_fdata fdata; ++ int len; ++ loff_t pos; ++ ssize_t ssz; ++ ++ ret = ERR_PTR(-EIO); ++ pos = 0; ++ ssz = vfsub_read_k(file, &fdata, sizeof(fdata), &pos); ++ if (unlikely(ssz != sizeof(fdata))) { ++ AuIOErr("ssz %zd, %u, %pD2\n", ++ ssz, (unsigned int)sizeof(fdata), file); ++ goto out; ++ } ++ ++ fdata.magic = ntohl((__force __be32)fdata.magic); ++ switch (fdata.magic) { ++ case AUFS_DRINFO_MAGIC_V1: ++ break; ++ default: ++ AuIOErr("magic-num 0x%x, 0x%x, %pD2\n", ++ fdata.magic, AUFS_DRINFO_MAGIC_V1, file); ++ goto out; ++ } ++ ++ drinfo = &fdata.drinfo; ++ len = drinfo->oldnamelen; ++ if (!len) { ++ AuIOErr("broken drinfo %pD2\n", file); ++ goto out; ++ } ++ ++ ret = NULL; ++ drinfo->ino = be64_to_cpu((__force __be64)drinfo->ino); ++ if (unlikely(h_ino && drinfo->ino != h_ino)) { ++ AuDbg("ignored i%llu, i%llu, %pD2\n", ++ (unsigned long long)drinfo->ino, ++ (unsigned long long)h_ino, file); ++ goto out; /* success */ ++ } ++ ++ ret = kmalloc(sizeof(*ret) + len, GFP_NOFS); ++ if (unlikely(!ret)) { ++ ret = ERR_PTR(-ENOMEM); ++ AuTraceErrPtr(ret); ++ goto out; ++ } ++ ++ *ret = *drinfo; ++ ssz = vfsub_read_k(file, (void *)ret->oldname, len, &pos); ++ if (unlikely(ssz != len)) { ++ au_kfree_rcu(ret); ++ ret = ERR_PTR(-EIO); ++ AuIOErr("ssz %zd, %u, %pD2\n", ssz, len, file); ++ goto out; ++ } ++ ++ AuDbg("oldname %.*s\n", ret->oldnamelen, ret->oldname); ++ ++out: ++ return ret; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* in order to be revertible */ ++struct au_drinfo_rev_elm { ++ int created; ++ struct dentry *info_dentry; ++ struct au_drinfo *info_last; ++}; ++ ++struct au_drinfo_rev { ++ unsigned char already; ++ aufs_bindex_t nelm; ++ struct au_drinfo_rev_elm elm[]; ++}; ++ ++/* todo: isn't it too large? */ ++struct au_drinfo_store { ++ struct path h_ppath; ++ struct dentry *h_dentry; ++ struct au_drinfo_fdata *fdata; ++ char *infoname; /* inside of whname, just after PFX */ ++ char whname[sizeof(AUFS_WH_DR_INFO_PFX) + AUFS_DIRREN_ENV_VAL_SZ]; ++ aufs_bindex_t btgt, btail; ++ unsigned char no_sio, ++ allocated, /* current size of *fdata */ ++ infonamelen, /* room size for p */ ++ whnamelen, /* length of the generated name */ ++ renameback; /* renamed back */ ++}; ++ ++/* on rename(2) error, the caller should revert it using @elm */ ++static int au_drinfo_do_store(struct au_drinfo_store *w, ++ struct au_drinfo_rev_elm *elm) ++{ ++ int err, len; ++ ssize_t ssz; ++ loff_t pos; ++ struct path infopath = { ++ .mnt = w->h_ppath.mnt ++ }; ++ struct inode *h_dir, *h_inode, *delegated; ++ struct file *infofile; ++ struct qstr *qname; ++ ++ AuDebugOn(elm ++ && memcmp(elm, page_address(ZERO_PAGE(0)), sizeof(*elm))); ++ ++ infopath.dentry = vfsub_lookup_one_len(w->whname, w->h_ppath.dentry, ++ w->whnamelen); ++ AuTraceErrPtr(infopath.dentry); ++ if (IS_ERR(infopath.dentry)) { ++ err = PTR_ERR(infopath.dentry); ++ goto out; ++ } ++ ++ err = 0; ++ h_dir = d_inode(w->h_ppath.dentry); ++ if (elm && d_is_negative(infopath.dentry)) { ++ err = vfsub_create(h_dir, &infopath, 0600, /*want_excl*/true); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ goto out_dput; ++ elm->created = 1; ++ elm->info_dentry = dget(infopath.dentry); ++ } ++ ++ infofile = vfsub_dentry_open(&infopath, O_RDWR); ++ AuTraceErrPtr(infofile); ++ if (IS_ERR(infofile)) { ++ err = PTR_ERR(infofile); ++ goto out_dput; ++ } ++ ++ h_inode = d_inode(infopath.dentry); ++ if (elm && i_size_read(h_inode)) { ++ h_inode = d_inode(w->h_dentry); ++ elm->info_last = au_drinfo_read_k(infofile, h_inode->i_ino); ++ AuTraceErrPtr(elm->info_last); ++ if (IS_ERR(elm->info_last)) { ++ err = PTR_ERR(elm->info_last); ++ elm->info_last = NULL; ++ AuDebugOn(elm->info_dentry); ++ goto out_fput; ++ } ++ } ++ ++ if (elm && w->renameback) { ++ delegated = NULL; ++ err = vfsub_unlink(h_dir, &infopath, &delegated, /*force*/0); ++ AuTraceErr(err); ++ if (unlikely(err == -EWOULDBLOCK)) ++ iput(delegated); ++ goto out_fput; ++ } ++ ++ pos = 0; ++ qname = &w->h_dentry->d_name; ++ len = sizeof(*w->fdata) + qname->len; ++ if (!elm) ++ len = sizeof(*w->fdata) + w->fdata->drinfo.oldnamelen; ++ ssz = vfsub_write_k(infofile, w->fdata, len, &pos); ++ if (ssz == len) { ++ AuDbg("hi%llu, %.*s\n", w->fdata->drinfo.ino, ++ w->fdata->drinfo.oldnamelen, w->fdata->drinfo.oldname); ++ goto out_fput; /* success */ ++ } else { ++ err = -EIO; ++ if (ssz < 0) ++ err = ssz; ++ /* the caller should revert it using @elm */ ++ } ++ ++out_fput: ++ fput(infofile); ++out_dput: ++ dput(infopath.dentry); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++struct au_call_drinfo_do_store_args { ++ int *errp; ++ struct au_drinfo_store *w; ++ struct au_drinfo_rev_elm *elm; ++}; ++ ++static void au_call_drinfo_do_store(void *args) ++{ ++ struct au_call_drinfo_do_store_args *a = args; ++ ++ *a->errp = au_drinfo_do_store(a->w, a->elm); ++} ++ ++static int au_drinfo_store_sio(struct au_drinfo_store *w, ++ struct au_drinfo_rev_elm *elm) ++{ ++ int err, wkq_err; ++ ++ if (w->no_sio) ++ err = au_drinfo_do_store(w, elm); ++ else { ++ struct au_call_drinfo_do_store_args a = { ++ .errp = &err, ++ .w = w, ++ .elm = elm ++ }; ++ wkq_err = au_wkq_wait(au_call_drinfo_do_store, &a); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ AuTraceErr(err); ++ ++ return err; ++} ++ ++static int au_drinfo_store_work_init(struct au_drinfo_store *w, ++ aufs_bindex_t btgt) ++{ ++ int err; ++ ++ memset(w, 0, sizeof(*w)); ++ w->allocated = roundup_pow_of_two(sizeof(*w->fdata) + 40); ++ strcpy(w->whname, AUFS_WH_DR_INFO_PFX); ++ w->infoname = w->whname + sizeof(AUFS_WH_DR_INFO_PFX) - 1; ++ w->infonamelen = sizeof(w->whname) - sizeof(AUFS_WH_DR_INFO_PFX); ++ w->btgt = btgt; ++ w->no_sio = !!uid_eq(current_fsuid(), GLOBAL_ROOT_UID); ++ ++ err = -ENOMEM; ++ w->fdata = kcalloc(1, w->allocated, GFP_NOFS); ++ if (unlikely(!w->fdata)) { ++ AuTraceErr(err); ++ goto out; ++ } ++ w->fdata->magic = (__force uint32_t)htonl(AUFS_DRINFO_MAGIC_V1); ++ err = 0; ++ ++out: ++ return err; ++} ++ ++static void au_drinfo_store_work_fin(struct au_drinfo_store *w) ++{ ++ au_kfree_rcu(w->fdata); ++} ++ ++static void au_drinfo_store_rev(struct au_drinfo_rev *rev, ++ struct au_drinfo_store *w) ++{ ++ struct au_drinfo_rev_elm *elm; ++ struct inode *h_dir, *delegated; ++ int err, nelm; ++ struct path infopath = { ++ .mnt = w->h_ppath.mnt ++ }; ++ ++ h_dir = d_inode(w->h_ppath.dentry); ++ IMustLock(h_dir); ++ ++ err = 0; ++ elm = rev->elm; ++ for (nelm = rev->nelm; nelm > 0; nelm--, elm++) { ++ AuDebugOn(elm->created && elm->info_last); ++ if (elm->created) { ++ AuDbg("here\n"); ++ delegated = NULL; ++ infopath.dentry = elm->info_dentry; ++ err = vfsub_unlink(h_dir, &infopath, &delegated, ++ !w->no_sio); ++ AuTraceErr(err); ++ if (unlikely(err == -EWOULDBLOCK)) ++ iput(delegated); ++ dput(elm->info_dentry); ++ } else if (elm->info_last) { ++ AuDbg("here\n"); ++ w->fdata->drinfo = *elm->info_last; ++ memcpy(w->fdata->drinfo.oldname, ++ elm->info_last->oldname, ++ elm->info_last->oldnamelen); ++ err = au_drinfo_store_sio(w, /*elm*/NULL); ++ au_kfree_rcu(elm->info_last); ++ } ++ if (unlikely(err)) ++ AuIOErr("%d, %s\n", err, w->whname); ++ /* go on even if err */ ++ } ++} ++ ++/* caller has to call au_dr_rename_fin() later */ ++static int au_drinfo_store(struct dentry *dentry, aufs_bindex_t btgt, ++ struct qstr *dst_name, void *_rev) ++{ ++ int err, sz, nelm; ++ aufs_bindex_t bindex, btail; ++ struct au_drinfo_store work; ++ struct au_drinfo_rev *rev, **p; ++ struct au_drinfo_rev_elm *elm; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_hinode *hdir; ++ ++ err = au_drinfo_store_work_init(&work, btgt); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ goto out; ++ ++ err = -ENOMEM; ++ btail = au_dbtaildir(dentry); ++ nelm = btail - btgt; ++ sz = sizeof(*rev) + sizeof(*elm) * nelm; ++ rev = kcalloc(1, sz, GFP_NOFS); ++ if (unlikely(!rev)) { ++ AuTraceErr(err); ++ goto out_args; ++ } ++ rev->nelm = nelm; ++ elm = rev->elm; ++ p = _rev; ++ *p = rev; ++ ++ err = 0; ++ sb = dentry->d_sb; ++ work.h_ppath.dentry = au_h_dptr(dentry, btgt); ++ work.h_ppath.mnt = au_sbr_mnt(sb, btgt); ++ hdir = au_hi(d_inode(dentry), btgt); ++ au_hn_inode_lock_nested(hdir, AuLsc_I_CHILD); ++ for (bindex = btgt + 1; bindex <= btail; bindex++, elm++) { ++ work.h_dentry = au_h_dptr(dentry, bindex); ++ if (!work.h_dentry) ++ continue; ++ ++ err = au_drinfo_construct(&work.fdata, work.h_dentry, ++ &work.allocated); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ break; ++ ++ work.renameback = au_qstreq(&work.h_dentry->d_name, dst_name); ++ br = au_sbr(sb, bindex); ++ work.whnamelen = sizeof(AUFS_WH_DR_INFO_PFX) - 1; ++ work.whnamelen += au_drinfo_name(br, work.infoname, ++ work.infonamelen); ++ AuDbg("whname %.*s, i%llu, %.*s\n", ++ work.whnamelen, work.whname, ++ be64_to_cpu((__force __be64)work.fdata->drinfo.ino), ++ work.fdata->drinfo.oldnamelen, ++ work.fdata->drinfo.oldname); ++ ++ err = au_drinfo_store_sio(&work, elm); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ break; ++ } ++ if (unlikely(err)) { ++ /* revert all drinfo */ ++ au_drinfo_store_rev(rev, &work); ++ au_kfree_try_rcu(rev); ++ *p = NULL; ++ } ++ au_hn_inode_unlock(hdir); ++ ++out_args: ++ au_drinfo_store_work_fin(&work); ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_dr_rename(struct dentry *src, aufs_bindex_t bindex, ++ struct qstr *dst_name, void *_rev) ++{ ++ int err, already; ++ ino_t ino; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_dr_br *dr; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ struct au_dr_hino *ent; ++ struct au_drinfo_rev *rev, **p; ++ ++ AuDbg("bindex %d\n", bindex); ++ ++ err = -ENOMEM; ++ ent = kmalloc(sizeof(*ent), GFP_NOFS); ++ if (unlikely(!ent)) ++ goto out; ++ ++ sb = src->d_sb; ++ br = au_sbr(sb, bindex); ++ dr = &br->br_dirren; ++ h_dentry = au_h_dptr(src, bindex); ++ h_inode = d_inode(h_dentry); ++ ino = h_inode->i_ino; ++ ent->dr_h_ino = ino; ++ already = au_dr_hino_test_add(dr, ino, ent); ++ AuDbg("b%d, hi%llu, already %d\n", ++ bindex, (unsigned long long)ino, already); ++ ++ err = au_drinfo_store(src, bindex, dst_name, _rev); ++ AuTraceErr(err); ++ if (!err) { ++ p = _rev; ++ rev = *p; ++ rev->already = already; ++ goto out; /* success */ ++ } ++ ++ /* revert */ ++ if (!already) ++ au_dr_hino_del(dr, ent); ++ au_kfree_rcu(ent); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_dr_rename_fin(struct dentry *src, aufs_bindex_t btgt, void *_rev) ++{ ++ struct au_drinfo_rev *rev; ++ struct au_drinfo_rev_elm *elm; ++ int nelm; ++ ++ rev = _rev; ++ elm = rev->elm; ++ for (nelm = rev->nelm; nelm > 0; nelm--, elm++) { ++ dput(elm->info_dentry); ++ au_kfree_rcu(elm->info_last); ++ } ++ au_kfree_try_rcu(rev); ++} ++ ++void au_dr_rename_rev(struct dentry *src, aufs_bindex_t btgt, void *_rev) ++{ ++ int err; ++ struct au_drinfo_store work; ++ struct au_drinfo_rev *rev = _rev; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct inode *h_inode; ++ struct au_dr_br *dr; ++ struct au_dr_hino *ent; ++ ++ err = au_drinfo_store_work_init(&work, btgt); ++ if (unlikely(err)) ++ goto out; ++ ++ sb = src->d_sb; ++ br = au_sbr(sb, btgt); ++ work.h_ppath.dentry = au_h_dptr(src, btgt); ++ work.h_ppath.mnt = au_br_mnt(br); ++ au_drinfo_store_rev(rev, &work); ++ au_drinfo_store_work_fin(&work); ++ if (rev->already) ++ goto out; ++ ++ dr = &br->br_dirren; ++ h_inode = d_inode(work.h_ppath.dentry); ++ ent = au_dr_hino_find(dr, h_inode->i_ino); ++ BUG_ON(!ent); ++ au_dr_hino_del(dr, ent); ++ au_kfree_rcu(ent); ++ ++out: ++ au_kfree_try_rcu(rev); ++ if (unlikely(err)) ++ pr_err("failed to remove dirren info\n"); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct au_drinfo *au_drinfo_do_load(struct path *h_ppath, ++ char *whname, int whnamelen, ++ struct dentry **info_dentry) ++{ ++ struct au_drinfo *drinfo; ++ struct file *f; ++ struct inode *h_dir; ++ struct path infopath; ++ int unlocked; ++ ++ AuDbg("%pd/%.*s\n", h_ppath->dentry, whnamelen, whname); ++ ++ *info_dentry = NULL; ++ drinfo = NULL; ++ unlocked = 0; ++ h_dir = d_inode(h_ppath->dentry); ++ inode_lock_shared_nested(h_dir, AuLsc_I_PARENT); ++ infopath.dentry = vfsub_lookup_one_len(whname, h_ppath->dentry, ++ whnamelen); ++ if (IS_ERR(infopath.dentry)) { ++ drinfo = (void *)infopath.dentry; ++ goto out; ++ } ++ ++ if (d_is_negative(infopath.dentry)) ++ goto out_dput; /* success */ ++ ++ infopath.mnt = h_ppath->mnt; ++ f = vfsub_dentry_open(&infopath, O_RDONLY); ++ inode_unlock_shared(h_dir); ++ unlocked = 1; ++ if (IS_ERR(f)) { ++ drinfo = (void *)f; ++ goto out_dput; ++ } ++ ++ drinfo = au_drinfo_read_k(f, /*h_ino*/0); ++ if (IS_ERR_OR_NULL(drinfo)) ++ goto out_fput; ++ ++ AuDbg("oldname %.*s\n", drinfo->oldnamelen, drinfo->oldname); ++ *info_dentry = dget(infopath.dentry); /* keep it alive */ ++ ++out_fput: ++ fput(f); ++out_dput: ++ dput(infopath.dentry); ++out: ++ if (!unlocked) ++ inode_unlock_shared(h_dir); ++ AuTraceErrPtr(drinfo); ++ return drinfo; ++} ++ ++struct au_drinfo_do_load_args { ++ struct au_drinfo **drinfop; ++ struct path *h_ppath; ++ char *whname; ++ int whnamelen; ++ struct dentry **info_dentry; ++}; ++ ++static void au_call_drinfo_do_load(void *args) ++{ ++ struct au_drinfo_do_load_args *a = args; ++ ++ *a->drinfop = au_drinfo_do_load(a->h_ppath, a->whname, a->whnamelen, ++ a->info_dentry); ++} ++ ++struct au_drinfo_load { ++ struct path h_ppath; ++ struct qstr *qname; ++ unsigned char no_sio; ++ ++ aufs_bindex_t ninfo; ++ struct au_drinfo **drinfo; ++}; ++ ++static int au_drinfo_load(struct au_drinfo_load *w, aufs_bindex_t bindex, ++ struct au_branch *br) ++{ ++ int err, wkq_err, whnamelen, e; ++ char whname[sizeof(AUFS_WH_DR_INFO_PFX) + AUFS_DIRREN_ENV_VAL_SZ] ++ = AUFS_WH_DR_INFO_PFX; ++ struct au_drinfo *drinfo; ++ struct qstr oldname; ++ struct inode *h_dir, *delegated; ++ struct dentry *info_dentry; ++ struct path infopath; ++ ++ whnamelen = sizeof(AUFS_WH_DR_INFO_PFX) - 1; ++ whnamelen += au_drinfo_name(br, whname + whnamelen, ++ sizeof(whname) - whnamelen); ++ if (w->no_sio) ++ drinfo = au_drinfo_do_load(&w->h_ppath, whname, whnamelen, ++ &info_dentry); ++ else { ++ struct au_drinfo_do_load_args args = { ++ .drinfop = &drinfo, ++ .h_ppath = &w->h_ppath, ++ .whname = whname, ++ .whnamelen = whnamelen, ++ .info_dentry = &info_dentry ++ }; ++ wkq_err = au_wkq_wait(au_call_drinfo_do_load, &args); ++ if (unlikely(wkq_err)) ++ drinfo = ERR_PTR(wkq_err); ++ } ++ err = PTR_ERR(drinfo); ++ if (IS_ERR_OR_NULL(drinfo)) ++ goto out; ++ ++ err = 0; ++ oldname.len = drinfo->oldnamelen; ++ oldname.name = drinfo->oldname; ++ if (au_qstreq(w->qname, &oldname)) { ++ /* the name is renamed back */ ++ au_kfree_rcu(drinfo); ++ drinfo = NULL; ++ ++ infopath.dentry = info_dentry; ++ infopath.mnt = w->h_ppath.mnt; ++ h_dir = d_inode(w->h_ppath.dentry); ++ delegated = NULL; ++ inode_lock_nested(h_dir, AuLsc_I_PARENT); ++ e = vfsub_unlink(h_dir, &infopath, &delegated, !w->no_sio); ++ inode_unlock(h_dir); ++ if (unlikely(e)) ++ AuIOErr("ignored %d, %pd2\n", e, &infopath.dentry); ++ if (unlikely(e == -EWOULDBLOCK)) ++ iput(delegated); ++ } ++ au_kfree_rcu(w->drinfo[bindex]); ++ w->drinfo[bindex] = drinfo; ++ dput(info_dentry); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_dr_lkup_free(struct au_drinfo **drinfo, int n) ++{ ++ struct au_drinfo **p = drinfo; ++ ++ while (n-- > 0) ++ au_kfree_rcu(*drinfo++); ++ au_kfree_try_rcu(p); ++} ++ ++int au_dr_lkup(struct au_do_lookup_args *lkup, struct dentry *dentry, ++ aufs_bindex_t btgt) ++{ ++ int err, ninfo; ++ struct au_drinfo_load w; ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ struct inode *h_dir; ++ struct au_dr_hino *ent; ++ struct super_block *sb; ++ ++ AuDbg("%.*s, name %.*s, whname %.*s, b%d\n", ++ AuLNPair(&dentry->d_name), AuLNPair(&lkup->dirren.dr_name), ++ AuLNPair(&lkup->whname), btgt); ++ ++ sb = dentry->d_sb; ++ bbot = au_sbbot(sb); ++ w.ninfo = bbot + 1; ++ if (!lkup->dirren.drinfo) { ++ lkup->dirren.drinfo = kcalloc(w.ninfo, ++ sizeof(*lkup->dirren.drinfo), ++ GFP_NOFS); ++ if (unlikely(!lkup->dirren.drinfo)) { ++ err = -ENOMEM; ++ goto out; ++ } ++ lkup->dirren.ninfo = w.ninfo; ++ } ++ w.drinfo = lkup->dirren.drinfo; ++ w.no_sio = !!uid_eq(current_fsuid(), GLOBAL_ROOT_UID); ++ w.h_ppath.dentry = au_h_dptr(dentry, btgt); ++ AuDebugOn(!w.h_ppath.dentry); ++ w.h_ppath.mnt = au_sbr_mnt(sb, btgt); ++ w.qname = &dentry->d_name; ++ ++ ninfo = 0; ++ for (bindex = btgt + 1; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ err = au_drinfo_load(&w, bindex, br); ++ if (unlikely(err)) ++ goto out_free; ++ if (w.drinfo[bindex]) ++ ninfo++; ++ } ++ if (!ninfo) { ++ br = au_sbr(sb, btgt); ++ h_dir = d_inode(w.h_ppath.dentry); ++ ent = au_dr_hino_find(&br->br_dirren, h_dir->i_ino); ++ AuDebugOn(!ent); ++ au_dr_hino_del(&br->br_dirren, ent); ++ au_kfree_rcu(ent); ++ } ++ goto out; /* success */ ++ ++out_free: ++ au_dr_lkup_free(lkup->dirren.drinfo, lkup->dirren.ninfo); ++ lkup->dirren.ninfo = 0; ++ lkup->dirren.drinfo = NULL; ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_dr_lkup_fin(struct au_do_lookup_args *lkup) ++{ ++ au_dr_lkup_free(lkup->dirren.drinfo, lkup->dirren.ninfo); ++} ++ ++int au_dr_lkup_name(struct au_do_lookup_args *lkup, aufs_bindex_t btgt) ++{ ++ int err; ++ struct au_drinfo *drinfo; ++ ++ err = 0; ++ if (!lkup->dirren.drinfo) ++ goto out; ++ AuDebugOn(lkup->dirren.ninfo <= btgt); ++ drinfo = lkup->dirren.drinfo[btgt]; ++ if (!drinfo) ++ goto out; ++ ++ au_kfree_try_rcu(lkup->whname.name); ++ lkup->whname.name = NULL; ++ lkup->dirren.dr_name.len = drinfo->oldnamelen; ++ lkup->dirren.dr_name.name = drinfo->oldname; ++ lkup->name = &lkup->dirren.dr_name; ++ err = au_wh_name_alloc(&lkup->whname, lkup->name); ++ if (!err) ++ AuDbg("name %.*s, whname %.*s, b%d\n", ++ AuLNPair(lkup->name), AuLNPair(&lkup->whname), ++ btgt); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_dr_lkup_h_ino(struct au_do_lookup_args *lkup, aufs_bindex_t bindex, ++ ino_t h_ino) ++{ ++ int match; ++ struct au_drinfo *drinfo; ++ ++ match = 1; ++ if (!lkup->dirren.drinfo) ++ goto out; ++ AuDebugOn(lkup->dirren.ninfo <= bindex); ++ drinfo = lkup->dirren.drinfo[bindex]; ++ if (!drinfo) ++ goto out; ++ ++ match = (drinfo->ino == h_ino); ++ AuDbg("match %d\n", match); ++ ++out: ++ return match; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_dr_opt_set(struct super_block *sb) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ ++ err = 0; ++ bbot = au_sbbot(sb); ++ for (bindex = 0; !err && bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ err = au_dr_hino(sb, bindex, /*br*/NULL, &br->br_path); ++ } ++ ++ return err; ++} ++ ++int au_dr_opt_flush(struct super_block *sb) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ ++ err = 0; ++ bbot = au_sbbot(sb); ++ for (bindex = 0; !err && bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_writable(br->br_perm)) ++ err = au_dr_hino(sb, bindex, /*br*/NULL, /*path*/NULL); ++ } ++ ++ return err; ++} ++ ++int au_dr_opt_clr(struct super_block *sb, int no_flush) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ ++ err = 0; ++ if (!no_flush) { ++ err = au_dr_opt_flush(sb); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ au_dr_hino_free(&br->br_dirren); ++ } ++ ++out: ++ return err; ++} +diff --git a/fs/aufs/dirren.h b/fs/aufs/dirren.h +new file mode 100644 +index 000000000000..ade589d2e75c +--- /dev/null ++++ b/fs/aufs/dirren.h +@@ -0,0 +1,127 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2017-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * renamed dir info ++ */ ++ ++#ifndef __AUFS_DIRREN_H__ ++#define __AUFS_DIRREN_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++#include ++#include "hbl.h" ++ ++#define AuDirren_NHASH 100 ++ ++#ifdef CONFIG_AUFS_DIRREN ++enum au_brid_type { ++ AuBrid_Unset, ++ AuBrid_UUID, ++ AuBrid_FSID, ++ AuBrid_DEV ++}; ++ ++struct au_dr_brid { ++ enum au_brid_type type; ++ union { ++ uuid_t uuid; /* unimplemented yet */ ++ fsid_t fsid; ++ dev_t dev; ++ }; ++}; ++ ++/* 20 is the max digits length of ulong 64 */ ++/* brid-type "_" uuid "_" inum */ ++#define AUFS_DIRREN_FNAME_SZ (1 + 1 + UUID_STRING_LEN + 20) ++#define AUFS_DIRREN_ENV_VAL_SZ (AUFS_DIRREN_FNAME_SZ + 1 + 20) ++ ++struct au_dr_hino { ++ struct hlist_bl_node dr_hnode; ++ ino_t dr_h_ino; ++}; ++ ++struct au_dr_br { ++ struct hlist_bl_head dr_h_ino[AuDirren_NHASH]; ++ struct au_dr_brid dr_brid; ++}; ++ ++struct au_dr_lookup { ++ /* dr_name is pointed by struct au_do_lookup_args.name */ ++ struct qstr dr_name; /* subset of dr_info */ ++ aufs_bindex_t ninfo; ++ struct au_drinfo **drinfo; ++}; ++#else ++struct au_dr_hino; ++/* empty */ ++struct au_dr_br { }; ++struct au_dr_lookup { }; ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_branch; ++struct au_do_lookup_args; ++struct au_hinode; ++#ifdef CONFIG_AUFS_DIRREN ++int au_dr_hino_test_add(struct au_dr_br *dr, ino_t h_ino, ++ struct au_dr_hino *add_ent); ++void au_dr_hino_free(struct au_dr_br *dr); ++int au_dr_br_init(struct super_block *sb, struct au_branch *br, ++ const struct path *path); ++int au_dr_br_fin(struct super_block *sb, struct au_branch *br); ++int au_dr_rename(struct dentry *src, aufs_bindex_t bindex, ++ struct qstr *dst_name, void *_rev); ++void au_dr_rename_fin(struct dentry *src, aufs_bindex_t btgt, void *rev); ++void au_dr_rename_rev(struct dentry *src, aufs_bindex_t bindex, void *rev); ++int au_dr_lkup(struct au_do_lookup_args *lkup, struct dentry *dentry, ++ aufs_bindex_t bindex); ++int au_dr_lkup_name(struct au_do_lookup_args *lkup, aufs_bindex_t btgt); ++int au_dr_lkup_h_ino(struct au_do_lookup_args *lkup, aufs_bindex_t bindex, ++ ino_t h_ino); ++void au_dr_lkup_fin(struct au_do_lookup_args *lkup); ++int au_dr_opt_set(struct super_block *sb); ++int au_dr_opt_flush(struct super_block *sb); ++int au_dr_opt_clr(struct super_block *sb, int no_flush); ++#else ++AuStubInt0(au_dr_hino_test_add, struct au_dr_br *dr, ino_t h_ino, ++ struct au_dr_hino *add_ent); ++AuStubVoid(au_dr_hino_free, struct au_dr_br *dr); ++AuStubInt0(au_dr_br_init, struct super_block *sb, struct au_branch *br, ++ const struct path *path); ++AuStubInt0(au_dr_br_fin, struct super_block *sb, struct au_branch *br); ++AuStubInt0(au_dr_rename, struct dentry *src, aufs_bindex_t bindex, ++ struct qstr *dst_name, void *_rev); ++AuStubVoid(au_dr_rename_fin, struct dentry *src, aufs_bindex_t btgt, void *rev); ++AuStubVoid(au_dr_rename_rev, struct dentry *src, aufs_bindex_t bindex, ++ void *rev); ++AuStubInt0(au_dr_lkup, struct au_do_lookup_args *lkup, struct dentry *dentry, ++ aufs_bindex_t bindex); ++AuStubInt0(au_dr_lkup_name, struct au_do_lookup_args *lkup, aufs_bindex_t btgt); ++AuStubInt0(au_dr_lkup_h_ino, struct au_do_lookup_args *lkup, ++ aufs_bindex_t bindex, ino_t h_ino); ++AuStubVoid(au_dr_lkup_fin, struct au_do_lookup_args *lkup); ++AuStubInt0(au_dr_opt_set, struct super_block *sb); ++AuStubInt0(au_dr_opt_flush, struct super_block *sb); ++AuStubInt0(au_dr_opt_clr, struct super_block *sb, int no_flush); ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_DIRREN ++static inline int au_dr_ihash(ino_t h_ino) ++{ ++ return h_ino % AuDirren_NHASH; ++} ++#else ++AuStubInt0(au_dr_ihash, ino_t h_ino); ++#endif ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DIRREN_H__ */ +diff --git a/fs/aufs/dynop.c b/fs/aufs/dynop.c +new file mode 100644 +index 000000000000..3c3e7812a021 +--- /dev/null ++++ b/fs/aufs/dynop.c +@@ -0,0 +1,354 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2010-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * dynamically customizable operations for regular files ++ */ ++ ++#include "aufs.h" ++ ++#define DyPrSym(key) AuDbgSym(key->dk_op.dy_hop) ++ ++/* ++ * How large will these lists be? ++ * Usually just a few elements, 20-30 at most for each, I guess. ++ */ ++static struct hlist_bl_head dynop[AuDyLast]; ++ ++static struct au_dykey *dy_gfind_get(struct hlist_bl_head *hbl, ++ const void *h_op) ++{ ++ struct au_dykey *key, *tmp; ++ struct hlist_bl_node *pos; ++ ++ key = NULL; ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(tmp, pos, hbl, dk_hnode) ++ if (tmp->dk_op.dy_hop == h_op) { ++ if (kref_get_unless_zero(&tmp->dk_kref)) ++ key = tmp; ++ break; ++ } ++ hlist_bl_unlock(hbl); ++ ++ return key; ++} ++ ++static struct au_dykey *dy_bradd(struct au_branch *br, struct au_dykey *key) ++{ ++ struct au_dykey **k, *found; ++ const void *h_op = key->dk_op.dy_hop; ++ int i; ++ ++ found = NULL; ++ k = br->br_dykey; ++ for (i = 0; i < AuBrDynOp; i++) ++ if (k[i]) { ++ if (k[i]->dk_op.dy_hop == h_op) { ++ found = k[i]; ++ break; ++ } ++ } else ++ break; ++ if (!found) { ++ spin_lock(&br->br_dykey_lock); ++ for (; i < AuBrDynOp; i++) ++ if (k[i]) { ++ if (k[i]->dk_op.dy_hop == h_op) { ++ found = k[i]; ++ break; ++ } ++ } else { ++ k[i] = key; ++ break; ++ } ++ spin_unlock(&br->br_dykey_lock); ++ BUG_ON(i == AuBrDynOp); /* expand the array */ ++ } ++ ++ return found; ++} ++ ++/* kref_get() if @key is already added */ ++static struct au_dykey *dy_gadd(struct hlist_bl_head *hbl, struct au_dykey *key) ++{ ++ struct au_dykey *tmp, *found; ++ struct hlist_bl_node *pos; ++ const void *h_op = key->dk_op.dy_hop; ++ ++ found = NULL; ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(tmp, pos, hbl, dk_hnode) ++ if (tmp->dk_op.dy_hop == h_op) { ++ if (kref_get_unless_zero(&tmp->dk_kref)) ++ found = tmp; ++ break; ++ } ++ if (!found) ++ hlist_bl_add_head(&key->dk_hnode, hbl); ++ hlist_bl_unlock(hbl); ++ ++ if (!found) ++ DyPrSym(key); ++ return found; ++} ++ ++static void dy_free_rcu(struct rcu_head *rcu) ++{ ++ struct au_dykey *key; ++ ++ key = container_of(rcu, struct au_dykey, dk_rcu); ++ DyPrSym(key); ++ kfree(key); ++} ++ ++static void dy_free(struct kref *kref) ++{ ++ struct au_dykey *key; ++ struct hlist_bl_head *hbl; ++ ++ key = container_of(kref, struct au_dykey, dk_kref); ++ hbl = dynop + key->dk_op.dy_type; ++ au_hbl_del(&key->dk_hnode, hbl); ++ call_rcu(&key->dk_rcu, dy_free_rcu); ++} ++ ++void au_dy_put(struct au_dykey *key) ++{ ++ kref_put(&key->dk_kref, dy_free); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define DyDbgSize(cnt, op) AuDebugOn(cnt != sizeof(op)/sizeof(void *)) ++ ++#ifdef CONFIG_AUFS_DEBUG ++#define DyDbgDeclare(cnt) unsigned int cnt = 0 ++#define DyDbgInc(cnt) do { cnt++; } while (0) ++#else ++#define DyDbgDeclare(cnt) do {} while (0) ++#define DyDbgInc(cnt) do {} while (0) ++#endif ++ ++#define DySet(func, dst, src, h_op, h_sb) do { \ ++ DyDbgInc(cnt); \ ++ if (h_op->func) { \ ++ if (src.func) \ ++ dst.func = src.func; \ ++ else \ ++ AuDbg("%s %s\n", au_sbtype(h_sb), #func); \ ++ } \ ++} while (0) ++ ++#define DySetForce(func, dst, src) do { \ ++ AuDebugOn(!src.func); \ ++ DyDbgInc(cnt); \ ++ dst.func = src.func; \ ++} while (0) ++ ++#define DySetAop(func) \ ++ DySet(func, dyaop->da_op, aufs_aop, h_aop, h_sb) ++#define DySetAopForce(func) \ ++ DySetForce(func, dyaop->da_op, aufs_aop) ++ ++static void dy_aop(struct au_dykey *key, const void *h_op, ++ struct super_block *h_sb __maybe_unused) ++{ ++ struct au_dyaop *dyaop = (void *)key; ++ const struct address_space_operations *h_aop = h_op; ++ DyDbgDeclare(cnt); ++ ++ AuDbg("%s\n", au_sbtype(h_sb)); ++ ++ DySetAop(writepage); ++ DySetAopForce(readpage); /* force */ ++ DySetAop(writepages); ++ DySetAop(set_page_dirty); ++ DySetAop(readpages); ++ DySetAop(write_begin); ++ DySetAop(write_end); ++ DySetAop(bmap); ++ DySetAop(invalidatepage); ++ DySetAop(releasepage); ++ DySetAop(freepage); ++ /* this one will be changed according to an aufs mount option */ ++ DySetAop(direct_IO); ++ DySetAop(migratepage); ++ DySetAop(isolate_page); ++ DySetAop(putback_page); ++ DySetAop(launder_page); ++ DySetAop(is_partially_uptodate); ++ DySetAop(is_dirty_writeback); ++ DySetAop(error_remove_page); ++ DySetAop(swap_activate); ++ DySetAop(swap_deactivate); ++ ++ DyDbgSize(cnt, *h_aop); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void dy_bug(struct kref *kref) ++{ ++ BUG(); ++} ++ ++static struct au_dykey *dy_get(struct au_dynop *op, struct au_branch *br) ++{ ++ struct au_dykey *key, *old; ++ struct hlist_bl_head *hbl; ++ struct op { ++ unsigned int sz; ++ void (*set)(struct au_dykey *key, const void *h_op, ++ struct super_block *h_sb __maybe_unused); ++ }; ++ static const struct op a[] = { ++ [AuDy_AOP] = { ++ .sz = sizeof(struct au_dyaop), ++ .set = dy_aop ++ } ++ }; ++ const struct op *p; ++ ++ hbl = dynop + op->dy_type; ++ key = dy_gfind_get(hbl, op->dy_hop); ++ if (key) ++ goto out_add; /* success */ ++ ++ p = a + op->dy_type; ++ key = kzalloc(p->sz, GFP_NOFS); ++ if (unlikely(!key)) { ++ key = ERR_PTR(-ENOMEM); ++ goto out; ++ } ++ ++ key->dk_op.dy_hop = op->dy_hop; ++ kref_init(&key->dk_kref); ++ p->set(key, op->dy_hop, au_br_sb(br)); ++ old = dy_gadd(hbl, key); ++ if (old) { ++ au_kfree_rcu(key); ++ key = old; ++ } ++ ++out_add: ++ old = dy_bradd(br, key); ++ if (old) ++ /* its ref-count should never be zero here */ ++ kref_put(&key->dk_kref, dy_bug); ++out: ++ return key; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * Aufs prohibits O_DIRECT by default even if the branch supports it. ++ * This behaviour is necessary to return an error from open(O_DIRECT) instead ++ * of the succeeding I/O. The dio mount option enables O_DIRECT and makes ++ * open(O_DIRECT) always succeed, but the succeeding I/O may return an error. ++ * See the aufs manual in detail. ++ */ ++static void dy_adx(struct au_dyaop *dyaop, int do_dx) ++{ ++ if (!do_dx) ++ dyaop->da_op.direct_IO = NULL; ++ else ++ dyaop->da_op.direct_IO = aufs_aop.direct_IO; ++} ++ ++static struct au_dyaop *dy_aget(struct au_branch *br, ++ const struct address_space_operations *h_aop, ++ int do_dx) ++{ ++ struct au_dyaop *dyaop; ++ struct au_dynop op; ++ ++ op.dy_type = AuDy_AOP; ++ op.dy_haop = h_aop; ++ dyaop = (void *)dy_get(&op, br); ++ if (IS_ERR(dyaop)) ++ goto out; ++ dy_adx(dyaop, do_dx); ++ ++out: ++ return dyaop; ++} ++ ++int au_dy_iaop(struct inode *inode, aufs_bindex_t bindex, ++ struct inode *h_inode) ++{ ++ int err, do_dx; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_dyaop *dyaop; ++ ++ AuDebugOn(!S_ISREG(h_inode->i_mode)); ++ IiMustWriteLock(inode); ++ ++ sb = inode->i_sb; ++ br = au_sbr(sb, bindex); ++ do_dx = !!au_opt_test(au_mntflags(sb), DIO); ++ dyaop = dy_aget(br, h_inode->i_mapping->a_ops, do_dx); ++ err = PTR_ERR(dyaop); ++ if (IS_ERR(dyaop)) ++ /* unnecessary to call dy_fput() */ ++ goto out; ++ ++ err = 0; ++ inode->i_mapping->a_ops = &dyaop->da_op; ++ ++out: ++ return err; ++} ++ ++/* ++ * Is it safe to replace a_ops during the inode/file is in operation? ++ * Yes, I hope so. ++ */ ++int au_dy_irefresh(struct inode *inode) ++{ ++ int err; ++ aufs_bindex_t btop; ++ struct inode *h_inode; ++ ++ err = 0; ++ if (S_ISREG(inode->i_mode)) { ++ btop = au_ibtop(inode); ++ h_inode = au_h_iptr(inode, btop); ++ err = au_dy_iaop(inode, btop, h_inode); ++ } ++ return err; ++} ++ ++void au_dy_arefresh(int do_dx) ++{ ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ struct au_dykey *key; ++ ++ hbl = dynop + AuDy_AOP; ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(key, pos, hbl, dk_hnode) ++ dy_adx((void *)key, do_dx); ++ hlist_bl_unlock(hbl); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void __init au_dy_init(void) ++{ ++ int i; ++ ++ for (i = 0; i < AuDyLast; i++) ++ INIT_HLIST_BL_HEAD(dynop + i); ++} ++ ++void au_dy_fin(void) ++{ ++ int i; ++ ++ for (i = 0; i < AuDyLast; i++) ++ WARN_ON(!hlist_bl_empty(dynop + i)); ++} +diff --git a/fs/aufs/dynop.h b/fs/aufs/dynop.h +new file mode 100644 +index 000000000000..66ac96bbf2ff +--- /dev/null ++++ b/fs/aufs/dynop.h +@@ -0,0 +1,64 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2010-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * dynamically customizable operations (for regular files only) ++ */ ++ ++#ifndef __AUFS_DYNOP_H__ ++#define __AUFS_DYNOP_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++ ++enum {AuDy_AOP, AuDyLast}; ++ ++struct au_dynop { ++ int dy_type; ++ union { ++ const void *dy_hop; ++ const struct address_space_operations *dy_haop; ++ }; ++}; ++ ++struct au_dykey { ++ union { ++ struct hlist_bl_node dk_hnode; ++ struct rcu_head dk_rcu; ++ }; ++ struct au_dynop dk_op; ++ ++ /* ++ * during I am in the branch local array, kref is gotten. when the ++ * branch is removed, kref is put. ++ */ ++ struct kref dk_kref; ++}; ++ ++/* stop unioning since their sizes are very different from each other */ ++struct au_dyaop { ++ struct au_dykey da_key; ++ struct address_space_operations da_op; /* not const */ ++}; ++/* make sure that 'struct au_dykey *' can be any type */ ++static_assert(!offsetof(struct au_dyaop, da_key)); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dynop.c */ ++struct au_branch; ++void au_dy_put(struct au_dykey *key); ++int au_dy_iaop(struct inode *inode, aufs_bindex_t bindex, ++ struct inode *h_inode); ++int au_dy_irefresh(struct inode *inode); ++void au_dy_arefresh(int do_dio); ++ ++void __init au_dy_init(void); ++void au_dy_fin(void); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DYNOP_H__ */ +diff --git a/fs/aufs/export.c b/fs/aufs/export.c +new file mode 100644 +index 000000000000..33ae8ac42c5c +--- /dev/null ++++ b/fs/aufs/export.c +@@ -0,0 +1,825 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * export via nfs ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include "aufs.h" ++ ++union conv { ++#ifdef CONFIG_AUFS_INO_T_64 ++ __u32 a[2]; ++#else ++ __u32 a[1]; ++#endif ++ ino_t ino; ++}; ++ ++static ino_t decode_ino(__u32 *a) ++{ ++ union conv u; ++ ++ BUILD_BUG_ON(sizeof(u.ino) != sizeof(u.a)); ++ u.a[0] = a[0]; ++#ifdef CONFIG_AUFS_INO_T_64 ++ u.a[1] = a[1]; ++#endif ++ return u.ino; ++} ++ ++static void encode_ino(__u32 *a, ino_t ino) ++{ ++ union conv u; ++ ++ u.ino = ino; ++ a[0] = u.a[0]; ++#ifdef CONFIG_AUFS_INO_T_64 ++ a[1] = u.a[1]; ++#endif ++} ++ ++/* NFS file handle */ ++enum { ++ Fh_br_id, ++ Fh_sigen, ++#ifdef CONFIG_AUFS_INO_T_64 ++ /* support 64bit inode number */ ++ Fh_ino1, ++ Fh_ino2, ++ Fh_dir_ino1, ++ Fh_dir_ino2, ++#else ++ Fh_ino1, ++ Fh_dir_ino1, ++#endif ++ Fh_igen, ++ Fh_h_type, ++ Fh_tail, ++ ++ Fh_ino = Fh_ino1, ++ Fh_dir_ino = Fh_dir_ino1 ++}; ++ ++static int au_test_anon(struct dentry *dentry) ++{ ++ /* note: read d_flags without d_lock */ ++ return !!(dentry->d_flags & DCACHE_DISCONNECTED); ++} ++ ++int au_test_nfsd(void) ++{ ++ int ret; ++ struct task_struct *tsk = current; ++ char comm[sizeof(tsk->comm)]; ++ ++ ret = 0; ++ if (tsk->flags & PF_KTHREAD) { ++ get_task_comm(comm, tsk); ++ ret = !strcmp(comm, "nfsd"); ++ } ++ ++ return ret; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* inode generation external table */ ++ ++void au_xigen_inc(struct inode *inode) ++{ ++ loff_t pos; ++ ssize_t sz; ++ __u32 igen; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++ sb = inode->i_sb; ++ AuDebugOn(!au_opt_test(au_mntflags(sb), XINO)); ++ ++ sbinfo = au_sbi(sb); ++ pos = inode->i_ino; ++ pos *= sizeof(igen); ++ igen = inode->i_generation + 1; ++ sz = xino_fwrite(sbinfo->si_xwrite, sbinfo->si_xigen, &igen, ++ sizeof(igen), &pos); ++ if (sz == sizeof(igen)) ++ return; /* success */ ++ ++ if (unlikely(sz >= 0)) ++ AuIOErr("xigen error (%zd)\n", sz); ++} ++ ++int au_xigen_new(struct inode *inode) ++{ ++ int err; ++ loff_t pos; ++ ssize_t sz; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ ++ err = 0; ++ /* todo: dirty, at mount time */ ++ if (inode->i_ino == AUFS_ROOT_INO) ++ goto out; ++ sb = inode->i_sb; ++ SiMustAnyLock(sb); ++ if (unlikely(!au_opt_test(au_mntflags(sb), XINO))) ++ goto out; ++ ++ err = -EFBIG; ++ pos = inode->i_ino; ++ if (unlikely(au_loff_max / sizeof(inode->i_generation) - 1 < pos)) { ++ AuIOErr1("too large i%lld\n", pos); ++ goto out; ++ } ++ pos *= sizeof(inode->i_generation); ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ file = sbinfo->si_xigen; ++ BUG_ON(!file); ++ ++ if (vfsub_f_size_read(file) ++ < pos + sizeof(inode->i_generation)) { ++ inode->i_generation = atomic_inc_return(&sbinfo->si_xigen_next); ++ sz = xino_fwrite(sbinfo->si_xwrite, file, &inode->i_generation, ++ sizeof(inode->i_generation), &pos); ++ } else ++ sz = xino_fread(sbinfo->si_xread, file, &inode->i_generation, ++ sizeof(inode->i_generation), &pos); ++ if (sz == sizeof(inode->i_generation)) ++ goto out; /* success */ ++ ++ err = sz; ++ if (unlikely(sz >= 0)) { ++ err = -EIO; ++ AuIOErr("xigen error (%zd)\n", sz); ++ } ++ ++out: ++ return err; ++} ++ ++int au_xigen_set(struct super_block *sb, struct path *path) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ file = au_xino_create2(sb, path, sbinfo->si_xigen); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ err = 0; ++ if (sbinfo->si_xigen) ++ fput(sbinfo->si_xigen); ++ sbinfo->si_xigen = file; ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_xigen_clr(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ if (sbinfo->si_xigen) { ++ fput(sbinfo->si_xigen); ++ sbinfo->si_xigen = NULL; ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry *decode_by_ino(struct super_block *sb, ino_t ino, ++ ino_t dir_ino) ++{ ++ struct dentry *dentry, *d; ++ struct inode *inode; ++ unsigned int sigen; ++ ++ dentry = NULL; ++ inode = ilookup(sb, ino); ++ if (!inode) ++ goto out; ++ ++ dentry = ERR_PTR(-ESTALE); ++ sigen = au_sigen(sb); ++ if (unlikely(au_is_bad_inode(inode) ++ || IS_DEADDIR(inode) ++ || sigen != au_iigen(inode, NULL))) ++ goto out_iput; ++ ++ dentry = NULL; ++ if (!dir_ino || S_ISDIR(inode->i_mode)) ++ dentry = d_find_alias(inode); ++ else { ++ spin_lock(&inode->i_lock); ++ hlist_for_each_entry(d, &inode->i_dentry, d_u.d_alias) { ++ spin_lock(&d->d_lock); ++ if (!au_test_anon(d) ++ && d_inode(d->d_parent)->i_ino == dir_ino) { ++ dentry = dget_dlock(d); ++ spin_unlock(&d->d_lock); ++ break; ++ } ++ spin_unlock(&d->d_lock); ++ } ++ spin_unlock(&inode->i_lock); ++ } ++ if (unlikely(dentry && au_digen_test(dentry, sigen))) { ++ /* need to refresh */ ++ dput(dentry); ++ dentry = NULL; ++ } ++ ++out_iput: ++ iput(inode); ++out: ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* todo: dirty? */ ++/* if exportfs_decode_fh() passed vfsmount*, we could be happy */ ++ ++struct au_compare_mnt_args { ++ /* input */ ++ struct super_block *sb; ++ ++ /* output */ ++ struct vfsmount *mnt; ++}; ++ ++static int au_compare_mnt(struct vfsmount *mnt, void *arg) ++{ ++ struct au_compare_mnt_args *a = arg; ++ ++ if (mnt->mnt_sb != a->sb) ++ return 0; ++ a->mnt = mntget(mnt); ++ return 1; ++} ++ ++static struct vfsmount *au_mnt_get(struct super_block *sb) ++{ ++ int err; ++ struct path root; ++ struct au_compare_mnt_args args = { ++ .sb = sb ++ }; ++ ++ get_fs_root(current->fs, &root); ++ rcu_read_lock(); ++ err = iterate_mounts(au_compare_mnt, &args, root.mnt); ++ rcu_read_unlock(); ++ path_put(&root); ++ AuDebugOn(!err); ++ AuDebugOn(!args.mnt); ++ return args.mnt; ++} ++ ++struct au_nfsd_si_lock { ++ unsigned int sigen; ++ aufs_bindex_t bindex, br_id; ++ unsigned char force_lock; ++}; ++ ++static int si_nfsd_read_lock(struct super_block *sb, ++ struct au_nfsd_si_lock *nsi_lock) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ ++ si_read_lock(sb, AuLock_FLUSH); ++ ++ /* branch id may be wrapped around */ ++ err = 0; ++ bindex = au_br_index(sb, nsi_lock->br_id); ++ if (bindex >= 0 && nsi_lock->sigen + AUFS_BRANCH_MAX > au_sigen(sb)) ++ goto out; /* success */ ++ ++ err = -ESTALE; ++ bindex = -1; ++ if (!nsi_lock->force_lock) ++ si_read_unlock(sb); ++ ++out: ++ nsi_lock->bindex = bindex; ++ return err; ++} ++ ++struct find_name_by_ino { ++ struct dir_context ctx; ++ int called, found; ++ ino_t ino; ++ char *name; ++ int namelen; ++}; ++ ++static int ++find_name_by_ino(struct dir_context *ctx, const char *name, int namelen, ++ loff_t offset, u64 ino, unsigned int d_type) ++{ ++ struct find_name_by_ino *a = container_of(ctx, struct find_name_by_ino, ++ ctx); ++ ++ a->called++; ++ if (a->ino != ino) ++ return 0; ++ ++ memcpy(a->name, name, namelen); ++ a->namelen = namelen; ++ a->found = 1; ++ return 1; ++} ++ ++static struct dentry *au_lkup_by_ino(struct path *path, ino_t ino, ++ struct au_nfsd_si_lock *nsi_lock) ++{ ++ struct dentry *dentry, *parent; ++ struct file *file; ++ struct inode *dir; ++ struct find_name_by_ino arg = { ++ .ctx = { ++ .actor = find_name_by_ino ++ } ++ }; ++ int err; ++ ++ parent = path->dentry; ++ if (nsi_lock) ++ si_read_unlock(parent->d_sb); ++ file = vfsub_dentry_open(path, au_dir_roflags); ++ dentry = (void *)file; ++ if (IS_ERR(file)) ++ goto out; ++ ++ dentry = ERR_PTR(-ENOMEM); ++ arg.name = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!arg.name)) ++ goto out_file; ++ arg.ino = ino; ++ arg.found = 0; ++ do { ++ arg.called = 0; ++ /* smp_mb(); */ ++ err = vfsub_iterate_dir(file, &arg.ctx); ++ } while (!err && !arg.found && arg.called); ++ dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_name; ++ /* instead of ENOENT */ ++ dentry = ERR_PTR(-ESTALE); ++ if (!arg.found) ++ goto out_name; ++ ++ /* do not call vfsub_lkup_one() */ ++ dir = d_inode(parent); ++ dentry = vfsub_lookup_one_len_unlocked(arg.name, parent, arg.namelen); ++ AuTraceErrPtr(dentry); ++ if (IS_ERR(dentry)) ++ goto out_name; ++ AuDebugOn(au_test_anon(dentry)); ++ if (unlikely(d_really_is_negative(dentry))) { ++ dput(dentry); ++ dentry = ERR_PTR(-ENOENT); ++ } ++ ++out_name: ++ free_page((unsigned long)arg.name); ++out_file: ++ fput(file); ++out: ++ if (unlikely(nsi_lock ++ && si_nfsd_read_lock(parent->d_sb, nsi_lock) < 0)) ++ if (!IS_ERR(dentry)) { ++ dput(dentry); ++ dentry = ERR_PTR(-ESTALE); ++ } ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++static struct dentry *decode_by_dir_ino(struct super_block *sb, ino_t ino, ++ ino_t dir_ino, ++ struct au_nfsd_si_lock *nsi_lock) ++{ ++ struct dentry *dentry; ++ struct path path; ++ ++ if (dir_ino != AUFS_ROOT_INO) { ++ path.dentry = decode_by_ino(sb, dir_ino, 0); ++ dentry = path.dentry; ++ if (!path.dentry || IS_ERR(path.dentry)) ++ goto out; ++ AuDebugOn(au_test_anon(path.dentry)); ++ } else ++ path.dentry = dget(sb->s_root); ++ ++ path.mnt = au_mnt_get(sb); ++ dentry = au_lkup_by_ino(&path, ino, nsi_lock); ++ path_put(&path); ++ ++out: ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int h_acceptable(void *expv, struct dentry *dentry) ++{ ++ return 1; ++} ++ ++static char *au_build_path(struct dentry *h_parent, struct path *h_rootpath, ++ char *buf, int len, struct super_block *sb) ++{ ++ char *p; ++ int n; ++ struct path path; ++ ++ p = d_path(h_rootpath, buf, len); ++ if (IS_ERR(p)) ++ goto out; ++ n = strlen(p); ++ ++ path.mnt = h_rootpath->mnt; ++ path.dentry = h_parent; ++ p = d_path(&path, buf, len); ++ if (IS_ERR(p)) ++ goto out; ++ if (n != 1) ++ p += n; ++ ++ path.mnt = au_mnt_get(sb); ++ path.dentry = sb->s_root; ++ p = d_path(&path, buf, len - strlen(p)); ++ mntput(path.mnt); ++ if (IS_ERR(p)) ++ goto out; ++ if (n != 1) ++ p[strlen(p)] = '/'; ++ ++out: ++ AuTraceErrPtr(p); ++ return p; ++} ++ ++static ++struct dentry *decode_by_path(struct super_block *sb, ino_t ino, __u32 *fh, ++ int fh_len, struct au_nfsd_si_lock *nsi_lock) ++{ ++ struct dentry *dentry, *h_parent, *root; ++ struct super_block *h_sb; ++ char *pathname, *p; ++ struct vfsmount *h_mnt; ++ struct au_branch *br; ++ int err; ++ struct path path; ++ ++ br = au_sbr(sb, nsi_lock->bindex); ++ h_mnt = au_br_mnt(br); ++ h_sb = h_mnt->mnt_sb; ++ /* todo: call lower fh_to_dentry()? fh_to_parent()? */ ++ lockdep_off(); ++ h_parent = exportfs_decode_fh(h_mnt, (void *)(fh + Fh_tail), ++ fh_len - Fh_tail, fh[Fh_h_type], ++ h_acceptable, /*context*/NULL); ++ lockdep_on(); ++ dentry = h_parent; ++ if (unlikely(!h_parent || IS_ERR(h_parent))) { ++ AuWarn1("%s decode_fh failed, %ld\n", ++ au_sbtype(h_sb), PTR_ERR(h_parent)); ++ goto out; ++ } ++ dentry = NULL; ++ if (unlikely(au_test_anon(h_parent))) { ++ AuWarn1("%s decode_fh returned a disconnected dentry\n", ++ au_sbtype(h_sb)); ++ goto out_h_parent; ++ } ++ ++ dentry = ERR_PTR(-ENOMEM); ++ pathname = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!pathname)) ++ goto out_h_parent; ++ ++ root = sb->s_root; ++ path.mnt = h_mnt; ++ di_read_lock_parent(root, !AuLock_IR); ++ path.dentry = au_h_dptr(root, nsi_lock->bindex); ++ di_read_unlock(root, !AuLock_IR); ++ p = au_build_path(h_parent, &path, pathname, PAGE_SIZE, sb); ++ dentry = (void *)p; ++ if (IS_ERR(p)) ++ goto out_pathname; ++ ++ si_read_unlock(sb); ++ err = vfsub_kern_path(p, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path); ++ dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_relock; ++ ++ dentry = ERR_PTR(-ENOENT); ++ AuDebugOn(au_test_anon(path.dentry)); ++ if (unlikely(d_really_is_negative(path.dentry))) ++ goto out_path; ++ ++ if (ino != d_inode(path.dentry)->i_ino) ++ dentry = au_lkup_by_ino(&path, ino, /*nsi_lock*/NULL); ++ else ++ dentry = dget(path.dentry); ++ ++out_path: ++ path_put(&path); ++out_relock: ++ if (unlikely(si_nfsd_read_lock(sb, nsi_lock) < 0)) ++ if (!IS_ERR(dentry)) { ++ dput(dentry); ++ dentry = ERR_PTR(-ESTALE); ++ } ++out_pathname: ++ free_page((unsigned long)pathname); ++out_h_parent: ++ dput(h_parent); ++out: ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry * ++aufs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, ++ int fh_type) ++{ ++ struct dentry *dentry; ++ __u32 *fh = fid->raw; ++ struct au_branch *br; ++ ino_t ino, dir_ino; ++ struct au_nfsd_si_lock nsi_lock = { ++ .force_lock = 0 ++ }; ++ ++ dentry = ERR_PTR(-ESTALE); ++ /* it should never happen, but the file handle is unreliable */ ++ if (unlikely(fh_len < Fh_tail)) ++ goto out; ++ nsi_lock.sigen = fh[Fh_sigen]; ++ nsi_lock.br_id = fh[Fh_br_id]; ++ ++ /* branch id may be wrapped around */ ++ br = NULL; ++ if (unlikely(si_nfsd_read_lock(sb, &nsi_lock))) ++ goto out; ++ nsi_lock.force_lock = 1; ++ ++ /* is this inode still cached? */ ++ ino = decode_ino(fh + Fh_ino); ++ /* it should never happen */ ++ if (unlikely(ino == AUFS_ROOT_INO)) ++ goto out_unlock; ++ ++ dir_ino = decode_ino(fh + Fh_dir_ino); ++ dentry = decode_by_ino(sb, ino, dir_ino); ++ if (IS_ERR(dentry)) ++ goto out_unlock; ++ if (dentry) ++ goto accept; ++ ++ /* is the parent dir cached? */ ++ br = au_sbr(sb, nsi_lock.bindex); ++ au_lcnt_inc(&br->br_nfiles); ++ dentry = decode_by_dir_ino(sb, ino, dir_ino, &nsi_lock); ++ if (IS_ERR(dentry)) ++ goto out_unlock; ++ if (dentry) ++ goto accept; ++ ++ /* lookup path */ ++ dentry = decode_by_path(sb, ino, fh, fh_len, &nsi_lock); ++ if (IS_ERR(dentry)) ++ goto out_unlock; ++ if (unlikely(!dentry)) ++ /* todo?: make it ESTALE */ ++ goto out_unlock; ++ ++accept: ++ if (!au_digen_test(dentry, au_sigen(sb)) ++ && d_inode(dentry)->i_generation == fh[Fh_igen]) ++ goto out_unlock; /* success */ ++ ++ dput(dentry); ++ dentry = ERR_PTR(-ESTALE); ++out_unlock: ++ if (br) ++ au_lcnt_dec(&br->br_nfiles); ++ si_read_unlock(sb); ++out: ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++#if 0 /* reserved for future use */ ++/* support subtreecheck option */ ++static struct dentry *aufs_fh_to_parent(struct super_block *sb, struct fid *fid, ++ int fh_len, int fh_type) ++{ ++ struct dentry *parent; ++ __u32 *fh = fid->raw; ++ ino_t dir_ino; ++ ++ dir_ino = decode_ino(fh + Fh_dir_ino); ++ parent = decode_by_ino(sb, dir_ino, 0); ++ if (IS_ERR(parent)) ++ goto out; ++ if (!parent) ++ parent = decode_by_path(sb, au_br_index(sb, fh[Fh_br_id]), ++ dir_ino, fh, fh_len); ++ ++out: ++ AuTraceErrPtr(parent); ++ return parent; ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_encode_fh(struct inode *inode, __u32 *fh, int *max_len, ++ struct inode *dir) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct super_block *sb, *h_sb; ++ struct dentry *dentry, *parent, *h_parent; ++ struct inode *h_dir; ++ struct au_branch *br; ++ ++ err = -ENOSPC; ++ if (unlikely(*max_len <= Fh_tail)) { ++ AuWarn1("NFSv2 client (max_len %d)?\n", *max_len); ++ goto out; ++ } ++ ++ err = FILEID_ROOT; ++ if (inode->i_ino == AUFS_ROOT_INO) { ++ AuDebugOn(inode->i_ino != AUFS_ROOT_INO); ++ goto out; ++ } ++ ++ h_parent = NULL; ++ sb = inode->i_sb; ++ err = si_read_lock(sb, AuLock_FLUSH); ++ if (unlikely(err)) ++ goto out; ++ ++#ifdef CONFIG_AUFS_DEBUG ++ if (unlikely(!au_opt_test(au_mntflags(sb), XINO))) ++ AuWarn1("NFS-exporting requires xino\n"); ++#endif ++ err = -EIO; ++ parent = NULL; ++ ii_read_lock_child(inode); ++ bindex = au_ibtop(inode); ++ if (!dir) { ++ dentry = d_find_any_alias(inode); ++ if (unlikely(!dentry)) ++ goto out_unlock; ++ AuDebugOn(au_test_anon(dentry)); ++ parent = dget_parent(dentry); ++ dput(dentry); ++ if (unlikely(!parent)) ++ goto out_unlock; ++ if (d_really_is_positive(parent)) ++ dir = d_inode(parent); ++ } ++ ++ ii_read_lock_parent(dir); ++ h_dir = au_h_iptr(dir, bindex); ++ ii_read_unlock(dir); ++ if (unlikely(!h_dir)) ++ goto out_parent; ++ h_parent = d_find_any_alias(h_dir); ++ if (unlikely(!h_parent)) ++ goto out_hparent; ++ ++ err = -EPERM; ++ br = au_sbr(sb, bindex); ++ h_sb = au_br_sb(br); ++ if (unlikely(!h_sb->s_export_op)) { ++ AuErr1("%s branch is not exportable\n", au_sbtype(h_sb)); ++ goto out_hparent; ++ } ++ ++ fh[Fh_br_id] = br->br_id; ++ fh[Fh_sigen] = au_sigen(sb); ++ encode_ino(fh + Fh_ino, inode->i_ino); ++ encode_ino(fh + Fh_dir_ino, dir->i_ino); ++ fh[Fh_igen] = inode->i_generation; ++ ++ *max_len -= Fh_tail; ++ fh[Fh_h_type] = exportfs_encode_fh(h_parent, (void *)(fh + Fh_tail), ++ max_len, ++ /*connectable or subtreecheck*/0); ++ err = fh[Fh_h_type]; ++ *max_len += Fh_tail; ++ /* todo: macros? */ ++ if (err != FILEID_INVALID) ++ err = 99; ++ else ++ AuWarn1("%s encode_fh failed\n", au_sbtype(h_sb)); ++ ++out_hparent: ++ dput(h_parent); ++out_parent: ++ dput(parent); ++out_unlock: ++ ii_read_unlock(inode); ++ si_read_unlock(sb); ++out: ++ if (unlikely(err < 0)) ++ err = FILEID_INVALID; ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_commit_metadata(struct inode *inode) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct super_block *sb; ++ struct inode *h_inode; ++ int (*f)(struct inode *inode); ++ ++ sb = inode->i_sb; ++ si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW); ++ ii_write_lock_child(inode); ++ bindex = au_ibtop(inode); ++ AuDebugOn(bindex < 0); ++ h_inode = au_h_iptr(inode, bindex); ++ ++ f = h_inode->i_sb->s_export_op->commit_metadata; ++ if (f) ++ err = f(h_inode); ++ else { ++ struct writeback_control wbc = { ++ .sync_mode = WB_SYNC_ALL, ++ .nr_to_write = 0 /* metadata only */ ++ }; ++ ++ err = sync_inode(h_inode, &wbc); ++ } ++ ++ au_cpup_attr_timesizes(inode); ++ ii_write_unlock(inode); ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct export_operations aufs_export_op = { ++ .fh_to_dentry = aufs_fh_to_dentry, ++ /* .fh_to_parent = aufs_fh_to_parent, */ ++ .encode_fh = aufs_encode_fh, ++ .commit_metadata = aufs_commit_metadata ++}; ++ ++void au_export_init(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ __u32 u; ++ ++ BUILD_BUG_ON_MSG(IS_BUILTIN(CONFIG_AUFS_FS) ++ && IS_MODULE(CONFIG_EXPORTFS), ++ AUFS_NAME ": unsupported configuration " ++ "CONFIG_EXPORTFS=m and CONFIG_AUFS_FS=y"); ++ ++ sb->s_export_op = &aufs_export_op; ++ sbinfo = au_sbi(sb); ++ sbinfo->si_xigen = NULL; ++ get_random_bytes(&u, sizeof(u)); ++ BUILD_BUG_ON(sizeof(u) != sizeof(int)); ++ atomic_set(&sbinfo->si_xigen_next, u); ++} +diff --git a/fs/aufs/f_op.c b/fs/aufs/f_op.c +new file mode 100644 +index 000000000000..c359b1441e96 +--- /dev/null ++++ b/fs/aufs/f_op.c +@@ -0,0 +1,806 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * file and vm operations ++ */ ++ ++#include ++#include ++#include ++#include ++#include "aufs.h" ++ ++int au_do_open_nondir(struct file *file, int flags, struct file *h_file) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct dentry *dentry, *h_dentry; ++ struct au_finfo *finfo; ++ struct inode *h_inode; ++ ++ FiMustWriteLock(file); ++ ++ err = 0; ++ dentry = file->f_path.dentry; ++ AuDebugOn(IS_ERR_OR_NULL(dentry)); ++ finfo = au_fi(file); ++ memset(&finfo->fi_htop, 0, sizeof(finfo->fi_htop)); ++ atomic_set(&finfo->fi_mmapped, 0); ++ bindex = au_dbtop(dentry); ++ if (!h_file) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ err = vfsub_test_mntns(file->f_path.mnt, h_dentry->d_sb); ++ if (unlikely(err)) ++ goto out; ++ h_file = au_h_open(dentry, bindex, flags, file, /*force_wr*/0); ++ if (IS_ERR(h_file)) { ++ err = PTR_ERR(h_file); ++ goto out; ++ } ++ } else { ++ h_dentry = h_file->f_path.dentry; ++ err = vfsub_test_mntns(file->f_path.mnt, h_dentry->d_sb); ++ if (unlikely(err)) ++ goto out; ++ /* br ref is already inc-ed */ ++ } ++ ++ if ((flags & __O_TMPFILE) ++ && !(flags & O_EXCL)) { ++ h_inode = file_inode(h_file); ++ spin_lock(&h_inode->i_lock); ++ h_inode->i_state |= I_LINKABLE; ++ spin_unlock(&h_inode->i_lock); ++ } ++ au_set_fbtop(file, bindex); ++ au_set_h_fptr(file, bindex, h_file); ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ ++out: ++ return err; ++} ++ ++static int aufs_open_nondir(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ int err; ++ struct super_block *sb; ++ struct au_do_open_args args = { ++ .open = au_do_open_nondir ++ }; ++ ++ AuDbg("%pD, f_flags 0x%x, f_mode 0x%x\n", ++ file, vfsub_file_flags(file), file->f_mode); ++ ++ sb = file->f_path.dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_do_open(file, &args); ++ si_read_unlock(sb); ++ return err; ++} ++ ++int aufs_release_nondir(struct inode *inode __maybe_unused, struct file *file) ++{ ++ struct au_finfo *finfo; ++ aufs_bindex_t bindex; ++ ++ finfo = au_fi(file); ++ au_hbl_del(&finfo->fi_hlist, ++ &au_sbi(file->f_path.dentry->d_sb)->si_files); ++ bindex = finfo->fi_btop; ++ if (bindex >= 0) ++ au_set_h_fptr(file, bindex, NULL); ++ ++ au_finfo_fin(file); ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_do_flush_nondir(struct file *file, fl_owner_t id) ++{ ++ int err; ++ struct file *h_file; ++ ++ err = 0; ++ h_file = au_hf_top(file); ++ if (h_file) ++ err = vfsub_flush(h_file, id); ++ return err; ++} ++ ++static int aufs_flush_nondir(struct file *file, fl_owner_t id) ++{ ++ return au_do_flush(file, id, au_do_flush_nondir); ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * read and write functions acquire [fdi]_rwsem once, but release before ++ * mmap_sem. This is because to stop a race condition between mmap(2). ++ * Releasing these aufs-rwsem should be safe, no branch-management (by keeping ++ * si_rwsem), no harmful copy-up should happen. Actually copy-up may happen in ++ * read functions after [fdi]_rwsem are released, but it should be harmless. ++ */ ++ ++/* Callers should call au_read_post() or fput() in the end */ ++struct file *au_read_pre(struct file *file, int keep_fi, unsigned int lsc) ++{ ++ struct file *h_file; ++ int err; ++ ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/0, lsc); ++ if (!err) { ++ di_read_unlock(file->f_path.dentry, AuLock_IR); ++ h_file = au_hf_top(file); ++ get_file(h_file); ++ if (!keep_fi) ++ fi_read_unlock(file); ++ } else ++ h_file = ERR_PTR(err); ++ ++ return h_file; ++} ++ ++static void au_read_post(struct inode *inode, struct file *h_file) ++{ ++ /* update without lock, I don't think it a problem */ ++ fsstack_copy_attr_atime(inode, file_inode(h_file)); ++ fput(h_file); ++} ++ ++struct au_write_pre { ++ /* input */ ++ unsigned int lsc; ++ ++ /* output */ ++ blkcnt_t blks; ++ aufs_bindex_t btop; ++}; ++ ++/* ++ * return with iinfo is write-locked ++ * callers should call au_write_post() or iinfo_write_unlock() + fput() in the ++ * end ++ */ ++static struct file *au_write_pre(struct file *file, int do_ready, ++ struct au_write_pre *wpre) ++{ ++ struct file *h_file; ++ struct dentry *dentry; ++ int err; ++ unsigned int lsc; ++ struct au_pin pin; ++ ++ lsc = 0; ++ if (wpre) ++ lsc = wpre->lsc; ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/1, lsc); ++ h_file = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ dentry = file->f_path.dentry; ++ if (do_ready) { ++ err = au_ready_to_write(file, -1, &pin); ++ if (unlikely(err)) { ++ h_file = ERR_PTR(err); ++ di_write_unlock(dentry); ++ goto out_fi; ++ } ++ } ++ ++ di_downgrade_lock(dentry, /*flags*/0); ++ if (wpre) ++ wpre->btop = au_fbtop(file); ++ h_file = au_hf_top(file); ++ get_file(h_file); ++ if (wpre) ++ wpre->blks = file_inode(h_file)->i_blocks; ++ if (do_ready) ++ au_unpin(&pin); ++ di_read_unlock(dentry, /*flags*/0); ++ ++out_fi: ++ fi_write_unlock(file); ++out: ++ return h_file; ++} ++ ++static void au_write_post(struct inode *inode, struct file *h_file, ++ struct au_write_pre *wpre, ssize_t written) ++{ ++ struct inode *h_inode; ++ ++ au_cpup_attr_timesizes(inode); ++ AuDebugOn(au_ibtop(inode) != wpre->btop); ++ h_inode = file_inode(h_file); ++ inode->i_mode = h_inode->i_mode; ++ ii_write_unlock(inode); ++ /* AuDbg("blks %llu, %llu\n", (u64)blks, (u64)h_inode->i_blocks); */ ++ if (written > 0) ++ au_fhsm_wrote(inode->i_sb, wpre->btop, ++ /*force*/h_inode->i_blocks > wpre->blks); ++ fput(h_file); ++} ++ ++static ssize_t aufs_read(struct file *file, char __user *buf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ struct inode *inode; ++ struct file *h_file; ++ struct super_block *sb; ++ ++ inode = file_inode(file); ++ sb = inode->i_sb; ++ si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW); ++ ++ h_file = au_read_pre(file, /*keep_fi*/0, /*lsc*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ /* filedata may be obsoleted by concurrent copyup, but no problem */ ++ err = vfsub_read_u(h_file, buf, count, ppos); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ au_read_post(inode, h_file); ++ ++out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ++ * todo: very ugly ++ * it locks both of i_mutex and si_rwsem for read in safe. ++ * if the plink maintenance mode continues forever (that is the problem), ++ * may loop forever. ++ */ ++static void au_mtx_and_read_lock(struct inode *inode) ++{ ++ int err; ++ struct super_block *sb = inode->i_sb; ++ ++ while (1) { ++ inode_lock(inode); ++ err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (!err) ++ break; ++ inode_unlock(inode); ++ si_read_lock(sb, AuLock_NOPLMW); ++ si_read_unlock(sb); ++ } ++} ++ ++static ssize_t aufs_write(struct file *file, const char __user *ubuf, ++ size_t count, loff_t *ppos) ++{ ++ ssize_t err; ++ struct au_write_pre wpre; ++ struct inode *inode; ++ struct file *h_file; ++ char __user *buf = (char __user *)ubuf; ++ ++ inode = file_inode(file); ++ au_mtx_and_read_lock(inode); ++ ++ wpre.lsc = 0; ++ h_file = au_write_pre(file, /*do_ready*/1, &wpre); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ err = vfsub_write_u(h_file, buf, count, ppos); ++ au_write_post(inode, h_file, &wpre, err); ++ ++out: ++ si_read_unlock(inode->i_sb); ++ inode_unlock(inode); ++ return err; ++} ++ ++static ssize_t au_do_iter(struct file *h_file, int rw, struct kiocb *kio, ++ struct iov_iter *iov_iter) ++{ ++ ssize_t err; ++ struct file *file; ++ ssize_t (*iter)(struct kiocb *, struct iov_iter *); ++ ++ err = security_file_permission(h_file, rw); ++ if (unlikely(err)) ++ goto out; ++ ++ err = -ENOSYS; /* the branch doesn't have its ->(read|write)_iter() */ ++ iter = NULL; ++ if (rw == MAY_READ) ++ iter = h_file->f_op->read_iter; ++ else if (rw == MAY_WRITE) ++ iter = h_file->f_op->write_iter; ++ ++ file = kio->ki_filp; ++ kio->ki_filp = h_file; ++ if (iter) { ++ lockdep_off(); ++ err = iter(kio, iov_iter); ++ lockdep_on(); ++ } else ++ /* currently there is no such fs */ ++ WARN_ON_ONCE(1); ++ kio->ki_filp = file; ++ ++out: ++ return err; ++} ++ ++static ssize_t aufs_read_iter(struct kiocb *kio, struct iov_iter *iov_iter) ++{ ++ ssize_t err; ++ struct file *file, *h_file; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ file = kio->ki_filp; ++ inode = file_inode(file); ++ sb = inode->i_sb; ++ si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW); ++ ++ h_file = au_read_pre(file, /*keep_fi*/1, /*lsc*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ if (au_test_loopback_kthread()) { ++ au_warn_loopback(h_file->f_path.dentry->d_sb); ++ if (file->f_mapping != h_file->f_mapping) { ++ file->f_mapping = h_file->f_mapping; ++ smp_mb(); /* unnecessary? */ ++ } ++ } ++ fi_read_unlock(file); ++ ++ err = au_do_iter(h_file, MAY_READ, kio, iov_iter); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ au_read_post(inode, h_file); ++ ++out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++static ssize_t aufs_write_iter(struct kiocb *kio, struct iov_iter *iov_iter) ++{ ++ ssize_t err; ++ struct au_write_pre wpre; ++ struct inode *inode; ++ struct file *file, *h_file; ++ ++ file = kio->ki_filp; ++ inode = file_inode(file); ++ au_mtx_and_read_lock(inode); ++ ++ wpre.lsc = 0; ++ h_file = au_write_pre(file, /*do_ready*/1, &wpre); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ err = au_do_iter(h_file, MAY_WRITE, kio, iov_iter); ++ au_write_post(inode, h_file, &wpre, err); ++ ++out: ++ si_read_unlock(inode->i_sb); ++ inode_unlock(inode); ++ return err; ++} ++ ++static ssize_t aufs_splice_read(struct file *file, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags) ++{ ++ ssize_t err; ++ struct file *h_file; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ inode = file_inode(file); ++ sb = inode->i_sb; ++ si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW); ++ ++ h_file = au_read_pre(file, /*keep_fi*/0, /*lsc*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ err = vfsub_splice_to(h_file, ppos, pipe, len, flags); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ au_read_post(inode, h_file); ++ ++out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++static ssize_t ++aufs_splice_write(struct pipe_inode_info *pipe, struct file *file, loff_t *ppos, ++ size_t len, unsigned int flags) ++{ ++ ssize_t err; ++ struct au_write_pre wpre; ++ struct inode *inode; ++ struct file *h_file; ++ ++ inode = file_inode(file); ++ au_mtx_and_read_lock(inode); ++ ++ wpre.lsc = 0; ++ h_file = au_write_pre(file, /*do_ready*/1, &wpre); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ err = vfsub_splice_from(pipe, h_file, ppos, len, flags); ++ au_write_post(inode, h_file, &wpre, err); ++ ++out: ++ si_read_unlock(inode->i_sb); ++ inode_unlock(inode); ++ return err; ++} ++ ++static long aufs_fallocate(struct file *file, int mode, loff_t offset, ++ loff_t len) ++{ ++ long err; ++ struct au_write_pre wpre; ++ struct inode *inode; ++ struct file *h_file; ++ ++ inode = file_inode(file); ++ au_mtx_and_read_lock(inode); ++ ++ wpre.lsc = 0; ++ h_file = au_write_pre(file, /*do_ready*/1, &wpre); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_fallocate(h_file, mode, offset, len); ++ lockdep_on(); ++ au_write_post(inode, h_file, &wpre, /*written*/1); ++ ++out: ++ si_read_unlock(inode->i_sb); ++ inode_unlock(inode); ++ return err; ++} ++ ++static ssize_t aufs_copy_file_range(struct file *src, loff_t src_pos, ++ struct file *dst, loff_t dst_pos, ++ size_t len, unsigned int flags) ++{ ++ ssize_t err; ++ struct au_write_pre wpre; ++ enum { SRC, DST }; ++ struct { ++ struct inode *inode; ++ struct file *h_file; ++ struct super_block *h_sb; ++ } a[2]; ++#define a_src a[SRC] ++#define a_dst a[DST] ++ ++ err = -EINVAL; ++ a_src.inode = file_inode(src); ++ if (unlikely(!S_ISREG(a_src.inode->i_mode))) ++ goto out; ++ a_dst.inode = file_inode(dst); ++ if (unlikely(!S_ISREG(a_dst.inode->i_mode))) ++ goto out; ++ ++ au_mtx_and_read_lock(a_dst.inode); ++ /* ++ * in order to match the order in di_write_lock2_{child,parent}(), ++ * use f_path.dentry for this comparison. ++ */ ++ if (src->f_path.dentry < dst->f_path.dentry) { ++ a_src.h_file = au_read_pre(src, /*keep_fi*/1, AuLsc_FI_1); ++ err = PTR_ERR(a_src.h_file); ++ if (IS_ERR(a_src.h_file)) ++ goto out_si; ++ ++ wpre.lsc = AuLsc_FI_2; ++ a_dst.h_file = au_write_pre(dst, /*do_ready*/1, &wpre); ++ err = PTR_ERR(a_dst.h_file); ++ if (IS_ERR(a_dst.h_file)) { ++ au_read_post(a_src.inode, a_src.h_file); ++ goto out_si; ++ } ++ } else { ++ wpre.lsc = AuLsc_FI_1; ++ a_dst.h_file = au_write_pre(dst, /*do_ready*/1, &wpre); ++ err = PTR_ERR(a_dst.h_file); ++ if (IS_ERR(a_dst.h_file)) ++ goto out_si; ++ ++ a_src.h_file = au_read_pre(src, /*keep_fi*/1, AuLsc_FI_2); ++ err = PTR_ERR(a_src.h_file); ++ if (IS_ERR(a_src.h_file)) { ++ au_write_post(a_dst.inode, a_dst.h_file, &wpre, ++ /*written*/0); ++ goto out_si; ++ } ++ } ++ ++ err = -EXDEV; ++ a_src.h_sb = file_inode(a_src.h_file)->i_sb; ++ a_dst.h_sb = file_inode(a_dst.h_file)->i_sb; ++ if (unlikely(a_src.h_sb != a_dst.h_sb)) { ++ AuDbgFile(src); ++ AuDbgFile(dst); ++ goto out_file; ++ } ++ ++ err = vfsub_copy_file_range(a_src.h_file, src_pos, a_dst.h_file, ++ dst_pos, len, flags); ++ ++out_file: ++ au_write_post(a_dst.inode, a_dst.h_file, &wpre, err); ++ fi_read_unlock(src); ++ au_read_post(a_src.inode, a_src.h_file); ++out_si: ++ si_read_unlock(a_dst.inode->i_sb); ++ inode_unlock(a_dst.inode); ++out: ++ return err; ++#undef a_src ++#undef a_dst ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * The locking order around current->mmap_sem. ++ * - in most and regular cases ++ * file I/O syscall -- aufs_read() or something ++ * -- si_rwsem for read -- mmap_sem ++ * (Note that [fdi]i_rwsem are released before mmap_sem). ++ * - in mmap case ++ * mmap(2) -- mmap_sem -- aufs_mmap() -- si_rwsem for read -- [fdi]i_rwsem ++ * This AB-BA order is definitely bad, but is not a problem since "si_rwsem for ++ * read" allows multiple processes to acquire it and [fdi]i_rwsem are not held ++ * in file I/O. Aufs needs to stop lockdep in aufs_mmap() though. ++ * It means that when aufs acquires si_rwsem for write, the process should never ++ * acquire mmap_sem. ++ * ++ * Actually aufs_iterate() holds [fdi]i_rwsem before mmap_sem, but this is not a ++ * problem either since any directory is not able to be mmap-ed. ++ * The similar scenario is applied to aufs_readlink() too. ++ */ ++ ++#if 0 /* stop calling security_file_mmap() */ ++/* cf. linux/include/linux/mman.h: calc_vm_prot_bits() */ ++#define AuConv_VM_PROT(f, b) _calc_vm_trans(f, VM_##b, PROT_##b) ++ ++static unsigned long au_arch_prot_conv(unsigned long flags) ++{ ++ /* currently ppc64 only */ ++#ifdef CONFIG_PPC64 ++ /* cf. linux/arch/powerpc/include/asm/mman.h */ ++ AuDebugOn(arch_calc_vm_prot_bits(-1) != VM_SAO); ++ return AuConv_VM_PROT(flags, SAO); ++#else ++ AuDebugOn(arch_calc_vm_prot_bits(-1)); ++ return 0; ++#endif ++} ++ ++static unsigned long au_prot_conv(unsigned long flags) ++{ ++ return AuConv_VM_PROT(flags, READ) ++ | AuConv_VM_PROT(flags, WRITE) ++ | AuConv_VM_PROT(flags, EXEC) ++ | au_arch_prot_conv(flags); ++} ++ ++/* cf. linux/include/linux/mman.h: calc_vm_flag_bits() */ ++#define AuConv_VM_MAP(f, b) _calc_vm_trans(f, VM_##b, MAP_##b) ++ ++static unsigned long au_flag_conv(unsigned long flags) ++{ ++ return AuConv_VM_MAP(flags, GROWSDOWN) ++ | AuConv_VM_MAP(flags, DENYWRITE) ++ | AuConv_VM_MAP(flags, LOCKED); ++} ++#endif ++ ++static int aufs_mmap(struct file *file, struct vm_area_struct *vma) ++{ ++ int err; ++ const unsigned char wlock ++ = (file->f_mode & FMODE_WRITE) && (vma->vm_flags & VM_SHARED); ++ struct super_block *sb; ++ struct file *h_file; ++ struct inode *inode; ++ ++ AuDbgVmRegion(file, vma); ++ ++ inode = file_inode(file); ++ sb = inode->i_sb; ++ lockdep_off(); ++ si_read_lock(sb, AuLock_NOPLMW); ++ ++ h_file = au_write_pre(file, wlock, /*wpre*/NULL); ++ lockdep_on(); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ err = 0; ++ au_set_mmapped(file); ++ au_vm_file_reset(vma, h_file); ++ /* ++ * we cannot call security_mmap_file() here since it may acquire ++ * mmap_sem or i_mutex. ++ * ++ * err = security_mmap_file(h_file, au_prot_conv(vma->vm_flags), ++ * au_flag_conv(vma->vm_flags)); ++ */ ++ if (!err) ++ err = call_mmap(h_file, vma); ++ if (!err) { ++ au_vm_prfile_set(vma, file); ++ fsstack_copy_attr_atime(inode, file_inode(h_file)); ++ goto out_fput; /* success */ ++ } ++ au_unset_mmapped(file); ++ au_vm_file_reset(vma, file); ++ ++out_fput: ++ lockdep_off(); ++ ii_write_unlock(inode); ++ lockdep_on(); ++ fput(h_file); ++out: ++ lockdep_off(); ++ si_read_unlock(sb); ++ lockdep_on(); ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_fsync_nondir(struct file *file, loff_t start, loff_t end, ++ int datasync) ++{ ++ int err; ++ struct au_write_pre wpre; ++ struct inode *inode; ++ struct file *h_file; ++ ++ err = 0; /* -EBADF; */ /* posix? */ ++ if (unlikely(!(file->f_mode & FMODE_WRITE))) ++ goto out; ++ ++ inode = file_inode(file); ++ au_mtx_and_read_lock(inode); ++ ++ wpre.lsc = 0; ++ h_file = au_write_pre(file, /*do_ready*/1, &wpre); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out_unlock; ++ ++ err = vfsub_fsync(h_file, &h_file->f_path, datasync); ++ au_write_post(inode, h_file, &wpre, /*written*/0); ++ ++out_unlock: ++ si_read_unlock(inode->i_sb); ++ inode_unlock(inode); ++out: ++ return err; ++} ++ ++static int aufs_fasync(int fd, struct file *file, int flag) ++{ ++ int err; ++ struct file *h_file; ++ struct super_block *sb; ++ ++ sb = file->f_path.dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW); ++ ++ h_file = au_read_pre(file, /*keep_fi*/0, /*lsc*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ if (h_file->f_op->fasync) ++ err = h_file->f_op->fasync(fd, h_file, flag); ++ fput(h_file); /* instead of au_read_post() */ ++ ++out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++static int aufs_setfl(struct file *file, unsigned long arg) ++{ ++ int err; ++ struct file *h_file; ++ struct super_block *sb; ++ ++ sb = file->f_path.dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW); ++ ++ h_file = au_read_pre(file, /*keep_fi*/0, /*lsc*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ /* stop calling h_file->fasync */ ++ arg |= vfsub_file_flags(file) & FASYNC; ++ err = setfl(/*unused fd*/-1, h_file, arg); ++ fput(h_file); /* instead of au_read_post() */ ++ ++out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* no one supports this operation, currently */ ++#if 0 /* reserved for future use */ ++static ssize_t aufs_sendpage(struct file *file, struct page *page, int offset, ++ size_t len, loff_t *pos, int more) ++{ ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++const struct file_operations aufs_file_fop = { ++ .owner = THIS_MODULE, ++ ++ .llseek = default_llseek, ++ ++ .read = aufs_read, ++ .write = aufs_write, ++ .read_iter = aufs_read_iter, ++ .write_iter = aufs_write_iter, ++ ++#ifdef CONFIG_AUFS_POLL ++ .poll = aufs_poll, ++#endif ++ .unlocked_ioctl = aufs_ioctl_nondir, ++#ifdef CONFIG_COMPAT ++ .compat_ioctl = aufs_compat_ioctl_nondir, ++#endif ++ .mmap = aufs_mmap, ++ .open = aufs_open_nondir, ++ .flush = aufs_flush_nondir, ++ .release = aufs_release_nondir, ++ .fsync = aufs_fsync_nondir, ++ .fasync = aufs_fasync, ++ /* .sendpage = aufs_sendpage, */ ++ .setfl = aufs_setfl, ++ .splice_write = aufs_splice_write, ++ .splice_read = aufs_splice_read, ++#if 0 /* reserved for future use */ ++ .aio_splice_write = aufs_aio_splice_write, ++ .aio_splice_read = aufs_aio_splice_read, ++#endif ++ .fallocate = aufs_fallocate, ++ .copy_file_range = aufs_copy_file_range ++}; +diff --git a/fs/aufs/fhsm.c b/fs/aufs/fhsm.c +new file mode 100644 +index 000000000000..cb054052cf9a +--- /dev/null ++++ b/fs/aufs/fhsm.c +@@ -0,0 +1,413 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2011-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * File-based Hierarchy Storage Management ++ */ ++ ++#include ++#include ++#include ++#include ++#include "aufs.h" ++ ++static aufs_bindex_t au_fhsm_bottom(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ ++ SiMustAnyLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ fhsm = &sbinfo->si_fhsm; ++ AuDebugOn(!fhsm); ++ return fhsm->fhsm_bottom; ++} ++ ++void au_fhsm_set_bottom(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ fhsm = &sbinfo->si_fhsm; ++ AuDebugOn(!fhsm); ++ fhsm->fhsm_bottom = bindex; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_fhsm_test_jiffy(struct au_sbinfo *sbinfo, struct au_branch *br) ++{ ++ struct au_br_fhsm *bf; ++ ++ bf = br->br_fhsm; ++ MtxMustLock(&bf->bf_lock); ++ ++ return !bf->bf_readable ++ || time_after(jiffies, ++ bf->bf_jiffy + sbinfo->si_fhsm.fhsm_expire); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_fhsm_notify(struct super_block *sb, int val) ++{ ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ ++ SiMustAnyLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ fhsm = &sbinfo->si_fhsm; ++ if (au_fhsm_pid(fhsm) ++ && atomic_read(&fhsm->fhsm_readable) != -1) { ++ atomic_set(&fhsm->fhsm_readable, val); ++ if (val) ++ wake_up(&fhsm->fhsm_wqh); ++ } ++} ++ ++static int au_fhsm_stfs(struct super_block *sb, aufs_bindex_t bindex, ++ struct aufs_stfs *rstfs, int do_lock, int do_notify) ++{ ++ int err; ++ struct au_branch *br; ++ struct au_br_fhsm *bf; ++ ++ br = au_sbr(sb, bindex); ++ AuDebugOn(au_br_rdonly(br)); ++ bf = br->br_fhsm; ++ AuDebugOn(!bf); ++ ++ if (do_lock) ++ mutex_lock(&bf->bf_lock); ++ else ++ MtxMustLock(&bf->bf_lock); ++ ++ /* sb->s_root for NFS is unreliable */ ++ err = au_br_stfs(br, &bf->bf_stfs); ++ if (unlikely(err)) { ++ AuErr1("FHSM failed (%d), b%d, ignored.\n", bindex, err); ++ goto out; ++ } ++ ++ bf->bf_jiffy = jiffies; ++ bf->bf_readable = 1; ++ if (do_notify) ++ au_fhsm_notify(sb, /*val*/1); ++ if (rstfs) ++ *rstfs = bf->bf_stfs; ++ ++out: ++ if (do_lock) ++ mutex_unlock(&bf->bf_lock); ++ au_fhsm_notify(sb, /*val*/1); ++ ++ return err; ++} ++ ++void au_fhsm_wrote(struct super_block *sb, aufs_bindex_t bindex, int force) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ struct au_branch *br; ++ struct au_br_fhsm *bf; ++ ++ AuDbg("b%d, force %d\n", bindex, force); ++ SiMustAnyLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ fhsm = &sbinfo->si_fhsm; ++ if (!au_ftest_si(sbinfo, FHSM) ++ || fhsm->fhsm_bottom == bindex) ++ return; ++ ++ br = au_sbr(sb, bindex); ++ bf = br->br_fhsm; ++ AuDebugOn(!bf); ++ mutex_lock(&bf->bf_lock); ++ if (force ++ || au_fhsm_pid(fhsm) ++ || au_fhsm_test_jiffy(sbinfo, br)) ++ err = au_fhsm_stfs(sb, bindex, /*rstfs*/NULL, /*do_lock*/0, ++ /*do_notify*/1); ++ mutex_unlock(&bf->bf_lock); ++} ++ ++void au_fhsm_wrote_all(struct super_block *sb, int force) ++{ ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ ++ /* exclude the bottom */ ++ bbot = au_fhsm_bottom(sb); ++ for (bindex = 0; bindex < bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_fhsm(br->br_perm)) ++ au_fhsm_wrote(sb, bindex, force); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static __poll_t au_fhsm_poll(struct file *file, struct poll_table_struct *wait) ++{ ++ __poll_t mask; ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ ++ mask = 0; ++ sbinfo = file->private_data; ++ fhsm = &sbinfo->si_fhsm; ++ poll_wait(file, &fhsm->fhsm_wqh, wait); ++ if (atomic_read(&fhsm->fhsm_readable)) ++ mask = EPOLLIN /* | EPOLLRDNORM */; ++ ++ if (!mask) ++ AuDbg("mask 0x%x\n", mask); ++ return mask; ++} ++ ++static int au_fhsm_do_read_one(struct aufs_stbr __user *stbr, ++ struct aufs_stfs *stfs, __s16 brid) ++{ ++ int err; ++ ++ err = copy_to_user(&stbr->stfs, stfs, sizeof(*stfs)); ++ if (!err) ++ err = __put_user(brid, &stbr->brid); ++ if (unlikely(err)) ++ err = -EFAULT; ++ ++ return err; ++} ++ ++static ssize_t au_fhsm_do_read(struct super_block *sb, ++ struct aufs_stbr __user *stbr, size_t count) ++{ ++ ssize_t err; ++ int nstbr; ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ struct au_br_fhsm *bf; ++ ++ /* except the bottom branch */ ++ err = 0; ++ nstbr = 0; ++ bbot = au_fhsm_bottom(sb); ++ for (bindex = 0; !err && bindex < bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (!au_br_fhsm(br->br_perm)) ++ continue; ++ ++ bf = br->br_fhsm; ++ mutex_lock(&bf->bf_lock); ++ if (bf->bf_readable) { ++ err = -EFAULT; ++ if (count >= sizeof(*stbr)) ++ err = au_fhsm_do_read_one(stbr++, &bf->bf_stfs, ++ br->br_id); ++ if (!err) { ++ bf->bf_readable = 0; ++ count -= sizeof(*stbr); ++ nstbr++; ++ } ++ } ++ mutex_unlock(&bf->bf_lock); ++ } ++ if (!err) ++ err = sizeof(*stbr) * nstbr; ++ ++ return err; ++} ++ ++static ssize_t au_fhsm_read(struct file *file, char __user *buf, size_t count, ++ loff_t *pos) ++{ ++ ssize_t err; ++ int readable; ++ aufs_bindex_t nfhsm, bindex, bbot; ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ struct au_branch *br; ++ struct super_block *sb; ++ ++ err = 0; ++ sbinfo = file->private_data; ++ fhsm = &sbinfo->si_fhsm; ++need_data: ++ spin_lock_irq(&fhsm->fhsm_wqh.lock); ++ if (!atomic_read(&fhsm->fhsm_readable)) { ++ if (vfsub_file_flags(file) & O_NONBLOCK) ++ err = -EAGAIN; ++ else ++ err = wait_event_interruptible_locked_irq ++ (fhsm->fhsm_wqh, ++ atomic_read(&fhsm->fhsm_readable)); ++ } ++ spin_unlock_irq(&fhsm->fhsm_wqh.lock); ++ if (unlikely(err)) ++ goto out; ++ ++ /* sb may already be dead */ ++ au_rw_read_lock(&sbinfo->si_rwsem); ++ readable = atomic_read(&fhsm->fhsm_readable); ++ if (readable > 0) { ++ sb = sbinfo->si_sb; ++ AuDebugOn(!sb); ++ /* exclude the bottom branch */ ++ nfhsm = 0; ++ bbot = au_fhsm_bottom(sb); ++ for (bindex = 0; bindex < bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_fhsm(br->br_perm)) ++ nfhsm++; ++ } ++ err = -EMSGSIZE; ++ if (nfhsm * sizeof(struct aufs_stbr) <= count) { ++ atomic_set(&fhsm->fhsm_readable, 0); ++ err = au_fhsm_do_read(sbinfo->si_sb, (void __user *)buf, ++ count); ++ } ++ } ++ au_rw_read_unlock(&sbinfo->si_rwsem); ++ if (!readable) ++ goto need_data; ++ ++out: ++ return err; ++} ++ ++static int au_fhsm_release(struct inode *inode, struct file *file) ++{ ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ ++ /* sb may already be dead */ ++ sbinfo = file->private_data; ++ fhsm = &sbinfo->si_fhsm; ++ spin_lock(&fhsm->fhsm_spin); ++ fhsm->fhsm_pid = 0; ++ spin_unlock(&fhsm->fhsm_spin); ++ kobject_put(&sbinfo->si_kobj); ++ ++ return 0; ++} ++ ++static const struct file_operations au_fhsm_fops = { ++ .owner = THIS_MODULE, ++ .llseek = noop_llseek, ++ .read = au_fhsm_read, ++ .poll = au_fhsm_poll, ++ .release = au_fhsm_release ++}; ++ ++int au_fhsm_fd(struct super_block *sb, int oflags) ++{ ++ int err, fd; ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ ++ err = -EPERM; ++ if (unlikely(!capable(CAP_SYS_ADMIN))) ++ goto out; ++ ++ err = -EINVAL; ++ if (unlikely(oflags & ~(O_CLOEXEC | O_NONBLOCK))) ++ goto out; ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ fhsm = &sbinfo->si_fhsm; ++ spin_lock(&fhsm->fhsm_spin); ++ if (!fhsm->fhsm_pid) ++ fhsm->fhsm_pid = current->pid; ++ else ++ err = -EBUSY; ++ spin_unlock(&fhsm->fhsm_spin); ++ if (unlikely(err)) ++ goto out; ++ ++ oflags |= O_RDONLY; ++ /* oflags |= FMODE_NONOTIFY; */ ++ fd = anon_inode_getfd("[aufs_fhsm]", &au_fhsm_fops, sbinfo, oflags); ++ err = fd; ++ if (unlikely(fd < 0)) ++ goto out_pid; ++ ++ /* succeed regardless 'fhsm' status */ ++ kobject_get(&sbinfo->si_kobj); ++ si_noflush_read_lock(sb); ++ if (au_ftest_si(sbinfo, FHSM)) ++ au_fhsm_wrote_all(sb, /*force*/0); ++ si_read_unlock(sb); ++ goto out; /* success */ ++ ++out_pid: ++ spin_lock(&fhsm->fhsm_spin); ++ fhsm->fhsm_pid = 0; ++ spin_unlock(&fhsm->fhsm_spin); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_fhsm_br_alloc(struct au_branch *br) ++{ ++ int err; ++ ++ err = 0; ++ br->br_fhsm = kmalloc(sizeof(*br->br_fhsm), GFP_NOFS); ++ if (br->br_fhsm) ++ au_br_fhsm_init(br->br_fhsm); ++ else ++ err = -ENOMEM; ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_fhsm_fin(struct super_block *sb) ++{ ++ au_fhsm_notify(sb, /*val*/-1); ++} ++ ++void au_fhsm_init(struct au_sbinfo *sbinfo) ++{ ++ struct au_fhsm *fhsm; ++ ++ fhsm = &sbinfo->si_fhsm; ++ spin_lock_init(&fhsm->fhsm_spin); ++ init_waitqueue_head(&fhsm->fhsm_wqh); ++ atomic_set(&fhsm->fhsm_readable, 0); ++ fhsm->fhsm_expire ++ = msecs_to_jiffies(AUFS_FHSM_CACHE_DEF_SEC * MSEC_PER_SEC); ++ fhsm->fhsm_bottom = -1; ++} ++ ++void au_fhsm_set(struct au_sbinfo *sbinfo, unsigned int sec) ++{ ++ sbinfo->si_fhsm.fhsm_expire ++ = msecs_to_jiffies(sec * MSEC_PER_SEC); ++} ++ ++void au_fhsm_show(struct seq_file *seq, struct au_sbinfo *sbinfo) ++{ ++ unsigned int u; ++ ++ if (!au_ftest_si(sbinfo, FHSM)) ++ return; ++ ++ u = jiffies_to_msecs(sbinfo->si_fhsm.fhsm_expire) / MSEC_PER_SEC; ++ if (u != AUFS_FHSM_CACHE_DEF_SEC) ++ seq_printf(seq, ",fhsm_sec=%u", u); ++} +diff --git a/fs/aufs/file.c b/fs/aufs/file.c +new file mode 100644 +index 000000000000..3911b2e7e46f +--- /dev/null ++++ b/fs/aufs/file.c +@@ -0,0 +1,850 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * handling file/dir, and address_space operation ++ */ ++ ++#ifdef CONFIG_AUFS_DEBUG ++#include ++#endif ++#include ++#include "aufs.h" ++ ++/* drop flags for writing */ ++unsigned int au_file_roflags(unsigned int flags) ++{ ++ flags &= ~(O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC); ++ flags |= O_RDONLY | O_NOATIME; ++ return flags; ++} ++ ++/* common functions to regular file and dir */ ++struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags, ++ struct file *file, int force_wr) ++{ ++ struct file *h_file; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct path h_path; ++ int err; ++ ++ /* a race condition can happen between open and unlink/rmdir */ ++ h_file = ERR_PTR(-ENOENT); ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (au_test_nfsd() && (!h_dentry || d_is_negative(h_dentry))) ++ goto out; ++ h_inode = d_inode(h_dentry); ++ spin_lock(&h_dentry->d_lock); ++ err = (!d_unhashed(dentry) && d_unlinked(h_dentry)) ++ /* || !d_inode(dentry)->i_nlink */ ++ ; ++ spin_unlock(&h_dentry->d_lock); ++ if (unlikely(err)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ br = au_sbr(sb, bindex); ++ err = au_br_test_oflag(flags, br); ++ h_file = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ /* drop flags for writing */ ++ if (au_test_ro(sb, bindex, d_inode(dentry))) { ++ if (force_wr && !(flags & O_WRONLY)) ++ force_wr = 0; ++ flags = au_file_roflags(flags); ++ if (force_wr) { ++ h_file = ERR_PTR(-EROFS); ++ flags = au_file_roflags(flags); ++ if (unlikely(vfsub_native_ro(h_inode) ++ || IS_APPEND(h_inode))) ++ goto out; ++ flags &= ~O_ACCMODE; ++ flags |= O_WRONLY; ++ } ++ } ++ flags &= ~O_CREAT; ++ au_lcnt_inc(&br->br_nfiles); ++ h_path.dentry = h_dentry; ++ h_path.mnt = au_br_mnt(br); ++ h_file = vfsub_dentry_open(&h_path, flags); ++ if (IS_ERR(h_file)) ++ goto out_br; ++ ++ if (flags & __FMODE_EXEC) { ++ err = deny_write_access(h_file); ++ if (unlikely(err)) { ++ fput(h_file); ++ h_file = ERR_PTR(err); ++ goto out_br; ++ } ++ } ++ fsnotify_open(h_file); ++ goto out; /* success */ ++ ++out_br: ++ au_lcnt_dec(&br->br_nfiles); ++out: ++ return h_file; ++} ++ ++static int au_cmoo(struct dentry *dentry) ++{ ++ int err, cmoo, matched; ++ unsigned int udba; ++ struct path h_path; ++ struct au_pin pin; ++ struct au_cp_generic cpg = { ++ .dentry = dentry, ++ .bdst = -1, ++ .bsrc = -1, ++ .len = -1, ++ .pin = &pin, ++ .flags = AuCpup_DTIME | AuCpup_HOPEN ++ }; ++ struct inode *delegated; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ struct au_fhsm *fhsm; ++ pid_t pid; ++ struct au_branch *br; ++ struct dentry *parent; ++ struct au_hinode *hdir; ++ ++ DiMustWriteLock(dentry); ++ IiMustWriteLock(d_inode(dentry)); ++ ++ err = 0; ++ if (IS_ROOT(dentry)) ++ goto out; ++ cpg.bsrc = au_dbtop(dentry); ++ if (!cpg.bsrc) ++ goto out; ++ ++ sb = dentry->d_sb; ++ sbinfo = au_sbi(sb); ++ fhsm = &sbinfo->si_fhsm; ++ pid = au_fhsm_pid(fhsm); ++ rcu_read_lock(); ++ matched = (pid ++ && (current->pid == pid ++ || rcu_dereference(current->real_parent)->pid == pid)); ++ rcu_read_unlock(); ++ if (matched) ++ goto out; ++ ++ br = au_sbr(sb, cpg.bsrc); ++ cmoo = au_br_cmoo(br->br_perm); ++ if (!cmoo) ++ goto out; ++ if (!d_is_reg(dentry)) ++ cmoo &= AuBrAttr_COO_ALL; ++ if (!cmoo) ++ goto out; ++ ++ parent = dget_parent(dentry); ++ di_write_lock_parent(parent); ++ err = au_wbr_do_copyup_bu(dentry, cpg.bsrc - 1); ++ cpg.bdst = err; ++ if (unlikely(err < 0)) { ++ err = 0; /* there is no upper writable branch */ ++ goto out_dgrade; ++ } ++ AuDbg("bsrc %d, bdst %d\n", cpg.bsrc, cpg.bdst); ++ ++ /* do not respect the coo attrib for the target branch */ ++ err = au_cpup_dirs(dentry, cpg.bdst); ++ if (unlikely(err)) ++ goto out_dgrade; ++ ++ di_downgrade_lock(parent, AuLock_IR); ++ udba = au_opt_udba(sb); ++ err = au_pin(&pin, dentry, cpg.bdst, udba, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ err = au_sio_cpup_simple(&cpg); ++ au_unpin(&pin); ++ if (unlikely(err)) ++ goto out_parent; ++ if (!(cmoo & AuBrWAttr_MOO)) ++ goto out_parent; /* success */ ++ ++ err = au_pin(&pin, dentry, cpg.bsrc, udba, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ h_path.mnt = au_br_mnt(br); ++ h_path.dentry = au_h_dptr(dentry, cpg.bsrc); ++ hdir = au_hi(d_inode(parent), cpg.bsrc); ++ delegated = NULL; ++ err = vfsub_unlink(hdir->hi_inode, &h_path, &delegated, /*force*/1); ++ au_unpin(&pin); ++ /* todo: keep h_dentry or not? */ ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ if (unlikely(err)) { ++ pr_err("unlink %pd after coo failed (%d), ignored\n", ++ dentry, err); ++ err = 0; ++ } ++ goto out_parent; /* success */ ++ ++out_dgrade: ++ di_downgrade_lock(parent, AuLock_IR); ++out_parent: ++ di_read_unlock(parent, AuLock_IR); ++ dput(parent); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_do_open(struct file *file, struct au_do_open_args *args) ++{ ++ int err, aopen = args->aopen; ++ struct dentry *dentry; ++ struct au_finfo *finfo; ++ ++ if (!aopen) ++ err = au_finfo_init(file, args->fidir); ++ else { ++ lockdep_off(); ++ err = au_finfo_init(file, args->fidir); ++ lockdep_on(); ++ } ++ if (unlikely(err)) ++ goto out; ++ ++ dentry = file->f_path.dentry; ++ AuDebugOn(IS_ERR_OR_NULL(dentry)); ++ di_write_lock_child(dentry); ++ err = au_cmoo(dentry); ++ di_downgrade_lock(dentry, AuLock_IR); ++ if (!err) { ++ if (!aopen) ++ err = args->open(file, vfsub_file_flags(file), NULL); ++ else { ++ lockdep_off(); ++ err = args->open(file, vfsub_file_flags(file), ++ args->h_file); ++ lockdep_on(); ++ } ++ } ++ di_read_unlock(dentry, AuLock_IR); ++ ++ finfo = au_fi(file); ++ if (!err) { ++ finfo->fi_file = file; ++ au_hbl_add(&finfo->fi_hlist, ++ &au_sbi(file->f_path.dentry->d_sb)->si_files); ++ } ++ if (!aopen) ++ fi_write_unlock(file); ++ else { ++ lockdep_off(); ++ fi_write_unlock(file); ++ lockdep_on(); ++ } ++ if (unlikely(err)) { ++ finfo->fi_hdir = NULL; ++ au_finfo_fin(file); ++ } ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_reopen_nondir(struct file *file) ++{ ++ int err; ++ aufs_bindex_t btop; ++ struct dentry *dentry; ++ struct au_branch *br; ++ struct file *h_file, *h_file_tmp; ++ ++ dentry = file->f_path.dentry; ++ btop = au_dbtop(dentry); ++ br = au_sbr(dentry->d_sb, btop); ++ h_file_tmp = NULL; ++ if (au_fbtop(file) == btop) { ++ h_file = au_hf_top(file); ++ if (file->f_mode == h_file->f_mode) ++ return 0; /* success */ ++ h_file_tmp = h_file; ++ get_file(h_file_tmp); ++ au_lcnt_inc(&br->br_nfiles); ++ au_set_h_fptr(file, btop, NULL); ++ } ++ AuDebugOn(au_fi(file)->fi_hdir); ++ /* ++ * it can happen ++ * file exists on both of rw and ro ++ * open --> dbtop and fbtop are both 0 ++ * prepend a branch as rw, "rw" become ro ++ * remove rw/file ++ * delete the top branch, "rw" becomes rw again ++ * --> dbtop is 1, fbtop is still 0 ++ * write --> fbtop is 0 but dbtop is 1 ++ */ ++ /* AuDebugOn(au_fbtop(file) < btop); */ ++ ++ h_file = au_h_open(dentry, btop, vfsub_file_flags(file) & ~O_TRUNC, ++ file, /*force_wr*/0); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) { ++ if (h_file_tmp) { ++ /* revert */ ++ au_set_h_fptr(file, btop, h_file_tmp); ++ h_file_tmp = NULL; ++ } ++ goto out; /* todo: close all? */ ++ } ++ ++ err = 0; ++ au_set_fbtop(file, btop); ++ au_set_h_fptr(file, btop, h_file); ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ ++out: ++ if (h_file_tmp) { ++ fput(h_file_tmp); ++ au_lcnt_dec(&br->br_nfiles); ++ } ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_reopen_wh(struct file *file, aufs_bindex_t btgt, ++ struct dentry *hi_wh) ++{ ++ int err; ++ aufs_bindex_t btop; ++ struct au_dinfo *dinfo; ++ struct dentry *h_dentry; ++ struct au_hdentry *hdp; ++ ++ dinfo = au_di(file->f_path.dentry); ++ AuRwMustWriteLock(&dinfo->di_rwsem); ++ ++ btop = dinfo->di_btop; ++ dinfo->di_btop = btgt; ++ hdp = au_hdentry(dinfo, btgt); ++ h_dentry = hdp->hd_dentry; ++ hdp->hd_dentry = hi_wh; ++ err = au_reopen_nondir(file); ++ hdp->hd_dentry = h_dentry; ++ dinfo->di_btop = btop; ++ ++ return err; ++} ++ ++static int au_ready_to_write_wh(struct file *file, loff_t len, ++ aufs_bindex_t bcpup, struct au_pin *pin) ++{ ++ int err; ++ struct inode *inode, *h_inode; ++ struct dentry *h_dentry, *hi_wh; ++ struct au_cp_generic cpg = { ++ .dentry = file->f_path.dentry, ++ .bdst = bcpup, ++ .bsrc = -1, ++ .len = len, ++ .pin = pin ++ }; ++ ++ au_update_dbtop(cpg.dentry); ++ inode = d_inode(cpg.dentry); ++ h_inode = NULL; ++ if (au_dbtop(cpg.dentry) <= bcpup ++ && au_dbbot(cpg.dentry) >= bcpup) { ++ h_dentry = au_h_dptr(cpg.dentry, bcpup); ++ if (h_dentry && d_is_positive(h_dentry)) ++ h_inode = d_inode(h_dentry); ++ } ++ hi_wh = au_hi_wh(inode, bcpup); ++ if (!hi_wh && !h_inode) ++ err = au_sio_cpup_wh(&cpg, file); ++ else ++ /* already copied-up after unlink */ ++ err = au_reopen_wh(file, bcpup, hi_wh); ++ ++ if (!err ++ && (inode->i_nlink > 1 ++ || (inode->i_state & I_LINKABLE)) ++ && au_opt_test(au_mntflags(cpg.dentry->d_sb), PLINK)) ++ au_plink_append(inode, bcpup, au_h_dptr(cpg.dentry, bcpup)); ++ ++ return err; ++} ++ ++/* ++ * prepare the @file for writing. ++ */ ++int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin) ++{ ++ int err; ++ aufs_bindex_t dbtop; ++ struct dentry *parent; ++ struct inode *inode; ++ struct super_block *sb; ++ struct file *h_file; ++ struct au_cp_generic cpg = { ++ .dentry = file->f_path.dentry, ++ .bdst = -1, ++ .bsrc = -1, ++ .len = len, ++ .pin = pin, ++ .flags = AuCpup_DTIME ++ }; ++ ++ sb = cpg.dentry->d_sb; ++ inode = d_inode(cpg.dentry); ++ cpg.bsrc = au_fbtop(file); ++ err = au_test_ro(sb, cpg.bsrc, inode); ++ if (!err && (au_hf_top(file)->f_mode & FMODE_WRITE)) { ++ err = au_pin(pin, cpg.dentry, cpg.bsrc, AuOpt_UDBA_NONE, ++ /*flags*/0); ++ goto out; ++ } ++ ++ /* need to cpup or reopen */ ++ parent = dget_parent(cpg.dentry); ++ di_write_lock_parent(parent); ++ err = AuWbrCopyup(au_sbi(sb), cpg.dentry); ++ cpg.bdst = err; ++ if (unlikely(err < 0)) ++ goto out_dgrade; ++ err = 0; ++ ++ if (!d_unhashed(cpg.dentry) && !au_h_dptr(parent, cpg.bdst)) { ++ err = au_cpup_dirs(cpg.dentry, cpg.bdst); ++ if (unlikely(err)) ++ goto out_dgrade; ++ } ++ ++ err = au_pin(pin, cpg.dentry, cpg.bdst, AuOpt_UDBA_NONE, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out_dgrade; ++ ++ dbtop = au_dbtop(cpg.dentry); ++ if (dbtop <= cpg.bdst) ++ cpg.bsrc = cpg.bdst; ++ ++ if (dbtop <= cpg.bdst /* just reopen */ ++ || !d_unhashed(cpg.dentry) /* copyup and reopen */ ++ ) { ++ h_file = au_h_open_pre(cpg.dentry, cpg.bsrc, /*force_wr*/0); ++ if (IS_ERR(h_file)) ++ err = PTR_ERR(h_file); ++ else { ++ di_downgrade_lock(parent, AuLock_IR); ++ if (dbtop > cpg.bdst) ++ err = au_sio_cpup_simple(&cpg); ++ if (!err) ++ err = au_reopen_nondir(file); ++ au_h_open_post(cpg.dentry, cpg.bsrc, h_file); ++ } ++ } else { /* copyup as wh and reopen */ ++ /* ++ * since writable hfsplus branch is not supported, ++ * h_open_pre/post() are unnecessary. ++ */ ++ err = au_ready_to_write_wh(file, len, cpg.bdst, pin); ++ di_downgrade_lock(parent, AuLock_IR); ++ } ++ ++ if (!err) { ++ au_pin_set_parent_lflag(pin, /*lflag*/0); ++ goto out_dput; /* success */ ++ } ++ au_unpin(pin); ++ goto out_unlock; ++ ++out_dgrade: ++ di_downgrade_lock(parent, AuLock_IR); ++out_unlock: ++ di_read_unlock(parent, AuLock_IR); ++out_dput: ++ dput(parent); ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_do_flush(struct file *file, fl_owner_t id, ++ int (*flush)(struct file *file, fl_owner_t id)) ++{ ++ int err; ++ struct super_block *sb; ++ struct inode *inode; ++ ++ inode = file_inode(file); ++ sb = inode->i_sb; ++ si_noflush_read_lock(sb); ++ fi_read_lock(file); ++ ii_read_lock_child(inode); ++ ++ err = flush(file, id); ++ au_cpup_attr_timesizes(inode); ++ ++ ii_read_unlock(inode); ++ fi_read_unlock(file); ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_file_refresh_by_inode(struct file *file, int *need_reopen) ++{ ++ int err; ++ struct au_pin pin; ++ struct au_finfo *finfo; ++ struct dentry *parent, *hi_wh; ++ struct inode *inode; ++ struct super_block *sb; ++ struct au_cp_generic cpg = { ++ .dentry = file->f_path.dentry, ++ .bdst = -1, ++ .bsrc = -1, ++ .len = -1, ++ .pin = &pin, ++ .flags = AuCpup_DTIME ++ }; ++ ++ FiMustWriteLock(file); ++ ++ err = 0; ++ finfo = au_fi(file); ++ sb = cpg.dentry->d_sb; ++ inode = d_inode(cpg.dentry); ++ cpg.bdst = au_ibtop(inode); ++ if (cpg.bdst == finfo->fi_btop || IS_ROOT(cpg.dentry)) ++ goto out; ++ ++ parent = dget_parent(cpg.dentry); ++ if (au_test_ro(sb, cpg.bdst, inode)) { ++ di_read_lock_parent(parent, !AuLock_IR); ++ err = AuWbrCopyup(au_sbi(sb), cpg.dentry); ++ cpg.bdst = err; ++ di_read_unlock(parent, !AuLock_IR); ++ if (unlikely(err < 0)) ++ goto out_parent; ++ err = 0; ++ } ++ ++ di_read_lock_parent(parent, AuLock_IR); ++ hi_wh = au_hi_wh(inode, cpg.bdst); ++ if (!S_ISDIR(inode->i_mode) ++ && au_opt_test(au_mntflags(sb), PLINK) ++ && au_plink_test(inode) ++ && !d_unhashed(cpg.dentry) ++ && cpg.bdst < au_dbtop(cpg.dentry)) { ++ err = au_test_and_cpup_dirs(cpg.dentry, cpg.bdst); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ /* always superio. */ ++ err = au_pin(&pin, cpg.dentry, cpg.bdst, AuOpt_UDBA_NONE, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (!err) { ++ err = au_sio_cpup_simple(&cpg); ++ au_unpin(&pin); ++ } ++ } else if (hi_wh) { ++ /* already copied-up after unlink */ ++ err = au_reopen_wh(file, cpg.bdst, hi_wh); ++ *need_reopen = 0; ++ } ++ ++out_unlock: ++ di_read_unlock(parent, AuLock_IR); ++out_parent: ++ dput(parent); ++out: ++ return err; ++} ++ ++static void au_do_refresh_dir(struct file *file) ++{ ++ aufs_bindex_t bindex, bbot, new_bindex, brid; ++ struct au_hfile *p, tmp, *q; ++ struct au_finfo *finfo; ++ struct super_block *sb; ++ struct au_fidir *fidir; ++ ++ FiMustWriteLock(file); ++ ++ sb = file->f_path.dentry->d_sb; ++ finfo = au_fi(file); ++ fidir = finfo->fi_hdir; ++ AuDebugOn(!fidir); ++ p = fidir->fd_hfile + finfo->fi_btop; ++ brid = p->hf_br->br_id; ++ bbot = fidir->fd_bbot; ++ for (bindex = finfo->fi_btop; bindex <= bbot; bindex++, p++) { ++ if (!p->hf_file) ++ continue; ++ ++ new_bindex = au_br_index(sb, p->hf_br->br_id); ++ if (new_bindex == bindex) ++ continue; ++ if (new_bindex < 0) { ++ au_set_h_fptr(file, bindex, NULL); ++ continue; ++ } ++ ++ /* swap two lower inode, and loop again */ ++ q = fidir->fd_hfile + new_bindex; ++ tmp = *q; ++ *q = *p; ++ *p = tmp; ++ if (tmp.hf_file) { ++ bindex--; ++ p--; ++ } ++ } ++ ++ p = fidir->fd_hfile; ++ if (!au_test_mmapped(file) && !d_unlinked(file->f_path.dentry)) { ++ bbot = au_sbbot(sb); ++ for (finfo->fi_btop = 0; finfo->fi_btop <= bbot; ++ finfo->fi_btop++, p++) ++ if (p->hf_file) { ++ if (file_inode(p->hf_file)) ++ break; ++ au_hfput(p, /*execed*/0); ++ } ++ } else { ++ bbot = au_br_index(sb, brid); ++ for (finfo->fi_btop = 0; finfo->fi_btop < bbot; ++ finfo->fi_btop++, p++) ++ if (p->hf_file) ++ au_hfput(p, /*execed*/0); ++ bbot = au_sbbot(sb); ++ } ++ ++ p = fidir->fd_hfile + bbot; ++ for (fidir->fd_bbot = bbot; fidir->fd_bbot >= finfo->fi_btop; ++ fidir->fd_bbot--, p--) ++ if (p->hf_file) { ++ if (file_inode(p->hf_file)) ++ break; ++ au_hfput(p, /*execed*/0); ++ } ++ AuDebugOn(fidir->fd_bbot < finfo->fi_btop); ++} ++ ++/* ++ * after branch manipulating, refresh the file. ++ */ ++static int refresh_file(struct file *file, int (*reopen)(struct file *file)) ++{ ++ int err, need_reopen, nbr; ++ aufs_bindex_t bbot, bindex; ++ struct dentry *dentry; ++ struct super_block *sb; ++ struct au_finfo *finfo; ++ struct au_hfile *hfile; ++ ++ dentry = file->f_path.dentry; ++ sb = dentry->d_sb; ++ nbr = au_sbbot(sb) + 1; ++ finfo = au_fi(file); ++ if (!finfo->fi_hdir) { ++ hfile = &finfo->fi_htop; ++ AuDebugOn(!hfile->hf_file); ++ bindex = au_br_index(sb, hfile->hf_br->br_id); ++ AuDebugOn(bindex < 0); ++ if (bindex != finfo->fi_btop) ++ au_set_fbtop(file, bindex); ++ } else { ++ err = au_fidir_realloc(finfo, nbr, /*may_shrink*/0); ++ if (unlikely(err)) ++ goto out; ++ au_do_refresh_dir(file); ++ } ++ ++ err = 0; ++ need_reopen = 1; ++ if (!au_test_mmapped(file)) ++ err = au_file_refresh_by_inode(file, &need_reopen); ++ if (finfo->fi_hdir) ++ /* harmless if err */ ++ au_fidir_realloc(finfo, nbr, /*may_shrink*/1); ++ if (!err && need_reopen && !d_unlinked(dentry)) ++ err = reopen(file); ++ if (!err) { ++ au_update_figen(file); ++ goto out; /* success */ ++ } ++ ++ /* error, close all lower files */ ++ if (finfo->fi_hdir) { ++ bbot = au_fbbot_dir(file); ++ for (bindex = au_fbtop(file); bindex <= bbot; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ } ++ ++out: ++ return err; ++} ++ ++/* common function to regular file and dir */ ++int au_reval_and_lock_fdi(struct file *file, int (*reopen)(struct file *file), ++ int wlock, unsigned int fi_lsc) ++{ ++ int err; ++ unsigned int sigen, figen; ++ aufs_bindex_t btop; ++ unsigned char pseudo_link; ++ struct dentry *dentry; ++ struct inode *inode; ++ ++ err = 0; ++ dentry = file->f_path.dentry; ++ inode = d_inode(dentry); ++ sigen = au_sigen(dentry->d_sb); ++ fi_write_lock_nested(file, fi_lsc); ++ figen = au_figen(file); ++ if (!fi_lsc) ++ di_write_lock_child(dentry); ++ else ++ di_write_lock_child2(dentry); ++ btop = au_dbtop(dentry); ++ pseudo_link = (btop != au_ibtop(inode)); ++ if (sigen == figen && !pseudo_link && au_fbtop(file) == btop) { ++ if (!wlock) { ++ di_downgrade_lock(dentry, AuLock_IR); ++ fi_downgrade_lock(file); ++ } ++ goto out; /* success */ ++ } ++ ++ AuDbg("sigen %d, figen %d\n", sigen, figen); ++ if (au_digen_test(dentry, sigen)) { ++ err = au_reval_dpath(dentry, sigen); ++ AuDebugOn(!err && au_digen_test(dentry, sigen)); ++ } ++ ++ if (!err) ++ err = refresh_file(file, reopen); ++ if (!err) { ++ if (!wlock) { ++ di_downgrade_lock(dentry, AuLock_IR); ++ fi_downgrade_lock(file); ++ } ++ } else { ++ di_write_unlock(dentry); ++ fi_write_unlock(file); ++ } ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* cf. aufs_nopage() */ ++/* for madvise(2) */ ++static int aufs_readpage(struct file *file __maybe_unused, struct page *page) ++{ ++ unlock_page(page); ++ return 0; ++} ++ ++/* it will never be called, but necessary to support O_DIRECT */ ++static ssize_t aufs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) ++{ BUG(); return 0; } ++ ++/* they will never be called. */ ++#ifdef CONFIG_AUFS_DEBUG ++static int aufs_write_begin(struct file *file, struct address_space *mapping, ++ loff_t pos, unsigned len, unsigned flags, ++ struct page **pagep, void **fsdata) ++{ AuUnsupport(); return 0; } ++static int aufs_write_end(struct file *file, struct address_space *mapping, ++ loff_t pos, unsigned len, unsigned copied, ++ struct page *page, void *fsdata) ++{ AuUnsupport(); return 0; } ++static int aufs_writepage(struct page *page, struct writeback_control *wbc) ++{ AuUnsupport(); return 0; } ++ ++static int aufs_set_page_dirty(struct page *page) ++{ AuUnsupport(); return 0; } ++static void aufs_invalidatepage(struct page *page, unsigned int offset, ++ unsigned int length) ++{ AuUnsupport(); } ++static int aufs_releasepage(struct page *page, gfp_t gfp) ++{ AuUnsupport(); return 0; } ++#if 0 /* called by memory compaction regardless file */ ++static int aufs_migratepage(struct address_space *mapping, struct page *newpage, ++ struct page *page, enum migrate_mode mode) ++{ AuUnsupport(); return 0; } ++#endif ++static bool aufs_isolate_page(struct page *page, isolate_mode_t mode) ++{ AuUnsupport(); return true; } ++static void aufs_putback_page(struct page *page) ++{ AuUnsupport(); } ++static int aufs_launder_page(struct page *page) ++{ AuUnsupport(); return 0; } ++static int aufs_is_partially_uptodate(struct page *page, ++ unsigned long from, ++ unsigned long count) ++{ AuUnsupport(); return 0; } ++static void aufs_is_dirty_writeback(struct page *page, bool *dirty, ++ bool *writeback) ++{ AuUnsupport(); } ++static int aufs_error_remove_page(struct address_space *mapping, ++ struct page *page) ++{ AuUnsupport(); return 0; } ++static int aufs_swap_activate(struct swap_info_struct *sis, struct file *file, ++ sector_t *span) ++{ AuUnsupport(); return 0; } ++static void aufs_swap_deactivate(struct file *file) ++{ AuUnsupport(); } ++#endif /* CONFIG_AUFS_DEBUG */ ++ ++const struct address_space_operations aufs_aop = { ++ .readpage = aufs_readpage, ++ .direct_IO = aufs_direct_IO, ++#ifdef CONFIG_AUFS_DEBUG ++ .writepage = aufs_writepage, ++ /* no writepages, because of writepage */ ++ .set_page_dirty = aufs_set_page_dirty, ++ /* no readpages, because of readpage */ ++ .write_begin = aufs_write_begin, ++ .write_end = aufs_write_end, ++ /* no bmap, no block device */ ++ .invalidatepage = aufs_invalidatepage, ++ .releasepage = aufs_releasepage, ++ /* is fallback_migrate_page ok? */ ++ /* .migratepage = aufs_migratepage, */ ++ .isolate_page = aufs_isolate_page, ++ .putback_page = aufs_putback_page, ++ .launder_page = aufs_launder_page, ++ .is_partially_uptodate = aufs_is_partially_uptodate, ++ .is_dirty_writeback = aufs_is_dirty_writeback, ++ .error_remove_page = aufs_error_remove_page, ++ .swap_activate = aufs_swap_activate, ++ .swap_deactivate = aufs_swap_deactivate ++#endif /* CONFIG_AUFS_DEBUG */ ++}; +diff --git a/fs/aufs/file.h b/fs/aufs/file.h +new file mode 100644 +index 000000000000..8bf8e67650d0 +--- /dev/null ++++ b/fs/aufs/file.h +@@ -0,0 +1,329 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * file operations ++ */ ++ ++#ifndef __AUFS_FILE_H__ ++#define __AUFS_FILE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++#include ++#include ++#include "rwsem.h" ++ ++struct au_branch; ++struct au_hfile { ++ struct file *hf_file; ++ struct au_branch *hf_br; ++}; ++ ++struct au_vdir; ++struct au_fidir { ++ aufs_bindex_t fd_bbot; ++ aufs_bindex_t fd_nent; ++ struct au_vdir *fd_vdir_cache; ++ struct au_hfile fd_hfile[]; ++}; ++ ++static inline int au_fidir_sz(int nent) ++{ ++ AuDebugOn(nent < 0); ++ return sizeof(struct au_fidir) + sizeof(struct au_hfile) * nent; ++} ++ ++struct au_finfo { ++ atomic_t fi_generation; ++ ++ struct au_rwsem fi_rwsem; ++ aufs_bindex_t fi_btop; ++ ++ /* do not union them */ ++ struct { /* for non-dir */ ++ struct au_hfile fi_htop; ++ atomic_t fi_mmapped; ++ }; ++ struct au_fidir *fi_hdir; /* for dir only */ ++ ++ struct hlist_bl_node fi_hlist; ++ struct file *fi_file; /* very ugly */ ++ struct rcu_head rcu; ++} ____cacheline_aligned_in_smp; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* file.c */ ++extern const struct address_space_operations aufs_aop; ++unsigned int au_file_roflags(unsigned int flags); ++struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags, ++ struct file *file, int force_wr); ++struct au_do_open_args { ++ int aopen; ++ int (*open)(struct file *file, int flags, ++ struct file *h_file); ++ struct au_fidir *fidir; ++ struct file *h_file; ++}; ++int au_do_open(struct file *file, struct au_do_open_args *args); ++int au_reopen_nondir(struct file *file); ++struct au_pin; ++int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin); ++int au_reval_and_lock_fdi(struct file *file, int (*reopen)(struct file *file), ++ int wlock, unsigned int fi_lsc); ++int au_do_flush(struct file *file, fl_owner_t id, ++ int (*flush)(struct file *file, fl_owner_t id)); ++ ++/* poll.c */ ++#ifdef CONFIG_AUFS_POLL ++__poll_t aufs_poll(struct file *file, struct poll_table_struct *pt); ++#endif ++ ++#ifdef CONFIG_AUFS_BR_HFSPLUS ++/* hfsplus.c */ ++struct file *au_h_open_pre(struct dentry *dentry, aufs_bindex_t bindex, ++ int force_wr); ++void au_h_open_post(struct dentry *dentry, aufs_bindex_t bindex, ++ struct file *h_file); ++#else ++AuStub(struct file *, au_h_open_pre, return NULL, struct dentry *dentry, ++ aufs_bindex_t bindex, int force_wr) ++AuStubVoid(au_h_open_post, struct dentry *dentry, aufs_bindex_t bindex, ++ struct file *h_file); ++#endif ++ ++/* f_op.c */ ++extern const struct file_operations aufs_file_fop; ++int au_do_open_nondir(struct file *file, int flags, struct file *h_file); ++int aufs_release_nondir(struct inode *inode __maybe_unused, struct file *file); ++struct file *au_read_pre(struct file *file, int keep_fi, unsigned int lsc); ++ ++/* finfo.c */ ++void au_hfput(struct au_hfile *hf, int execed); ++void au_set_h_fptr(struct file *file, aufs_bindex_t bindex, ++ struct file *h_file); ++ ++void au_update_figen(struct file *file); ++struct au_fidir *au_fidir_alloc(struct super_block *sb); ++int au_fidir_realloc(struct au_finfo *finfo, int nbr, int may_shrink); ++ ++void au_fi_init_once(void *_fi); ++void au_finfo_fin(struct file *file); ++int au_finfo_init(struct file *file, struct au_fidir *fidir); ++ ++/* ioctl.c */ ++long aufs_ioctl_nondir(struct file *file, unsigned int cmd, unsigned long arg); ++#ifdef CONFIG_COMPAT ++long aufs_compat_ioctl_dir(struct file *file, unsigned int cmd, ++ unsigned long arg); ++long aufs_compat_ioctl_nondir(struct file *file, unsigned int cmd, ++ unsigned long arg); ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_finfo *au_fi(struct file *file) ++{ ++ return file->private_data; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define fi_read_lock(f) au_rw_read_lock(&au_fi(f)->fi_rwsem) ++#define fi_write_lock(f) au_rw_write_lock(&au_fi(f)->fi_rwsem) ++#define fi_read_trylock(f) au_rw_read_trylock(&au_fi(f)->fi_rwsem) ++#define fi_write_trylock(f) au_rw_write_trylock(&au_fi(f)->fi_rwsem) ++/* ++#define fi_read_trylock_nested(f) \ ++ au_rw_read_trylock_nested(&au_fi(f)->fi_rwsem) ++#define fi_write_trylock_nested(f) \ ++ au_rw_write_trylock_nested(&au_fi(f)->fi_rwsem) ++*/ ++ ++#define fi_read_unlock(f) au_rw_read_unlock(&au_fi(f)->fi_rwsem) ++#define fi_write_unlock(f) au_rw_write_unlock(&au_fi(f)->fi_rwsem) ++#define fi_downgrade_lock(f) au_rw_dgrade_lock(&au_fi(f)->fi_rwsem) ++ ++/* lock subclass for finfo */ ++enum { ++ AuLsc_FI_1, ++ AuLsc_FI_2 ++}; ++ ++static inline void fi_read_lock_nested(struct file *f, unsigned int lsc) ++{ ++ au_rw_read_lock_nested(&au_fi(f)->fi_rwsem, lsc); ++} ++ ++static inline void fi_write_lock_nested(struct file *f, unsigned int lsc) ++{ ++ au_rw_write_lock_nested(&au_fi(f)->fi_rwsem, lsc); ++} ++ ++/* ++ * fi_read_lock_1, fi_write_lock_1, ++ * fi_read_lock_2, fi_write_lock_2 ++ */ ++#define AuReadLockFunc(name) \ ++static inline void fi_read_lock_##name(struct file *f) \ ++{ fi_read_lock_nested(f, AuLsc_FI_##name); } ++ ++#define AuWriteLockFunc(name) \ ++static inline void fi_write_lock_##name(struct file *f) \ ++{ fi_write_lock_nested(f, AuLsc_FI_##name); } ++ ++#define AuRWLockFuncs(name) \ ++ AuReadLockFunc(name) \ ++ AuWriteLockFunc(name) ++ ++AuRWLockFuncs(1); ++AuRWLockFuncs(2); ++ ++#undef AuReadLockFunc ++#undef AuWriteLockFunc ++#undef AuRWLockFuncs ++ ++#define FiMustNoWaiters(f) AuRwMustNoWaiters(&au_fi(f)->fi_rwsem) ++#define FiMustAnyLock(f) AuRwMustAnyLock(&au_fi(f)->fi_rwsem) ++#define FiMustWriteLock(f) AuRwMustWriteLock(&au_fi(f)->fi_rwsem) ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* todo: hard/soft set? */ ++static inline aufs_bindex_t au_fbtop(struct file *file) ++{ ++ FiMustAnyLock(file); ++ return au_fi(file)->fi_btop; ++} ++ ++static inline aufs_bindex_t au_fbbot_dir(struct file *file) ++{ ++ FiMustAnyLock(file); ++ AuDebugOn(!au_fi(file)->fi_hdir); ++ return au_fi(file)->fi_hdir->fd_bbot; ++} ++ ++static inline struct au_vdir *au_fvdir_cache(struct file *file) ++{ ++ FiMustAnyLock(file); ++ AuDebugOn(!au_fi(file)->fi_hdir); ++ return au_fi(file)->fi_hdir->fd_vdir_cache; ++} ++ ++static inline void au_set_fbtop(struct file *file, aufs_bindex_t bindex) ++{ ++ FiMustWriteLock(file); ++ au_fi(file)->fi_btop = bindex; ++} ++ ++static inline void au_set_fbbot_dir(struct file *file, aufs_bindex_t bindex) ++{ ++ FiMustWriteLock(file); ++ AuDebugOn(!au_fi(file)->fi_hdir); ++ au_fi(file)->fi_hdir->fd_bbot = bindex; ++} ++ ++static inline void au_set_fvdir_cache(struct file *file, ++ struct au_vdir *vdir_cache) ++{ ++ FiMustWriteLock(file); ++ AuDebugOn(!au_fi(file)->fi_hdir); ++ au_fi(file)->fi_hdir->fd_vdir_cache = vdir_cache; ++} ++ ++static inline struct file *au_hf_top(struct file *file) ++{ ++ FiMustAnyLock(file); ++ AuDebugOn(au_fi(file)->fi_hdir); ++ return au_fi(file)->fi_htop.hf_file; ++} ++ ++static inline struct file *au_hf_dir(struct file *file, aufs_bindex_t bindex) ++{ ++ FiMustAnyLock(file); ++ AuDebugOn(!au_fi(file)->fi_hdir); ++ return au_fi(file)->fi_hdir->fd_hfile[0 + bindex].hf_file; ++} ++ ++/* todo: memory barrier? */ ++static inline unsigned int au_figen(struct file *f) ++{ ++ return atomic_read(&au_fi(f)->fi_generation); ++} ++ ++static inline void au_set_mmapped(struct file *f) ++{ ++ if (atomic_inc_return(&au_fi(f)->fi_mmapped)) ++ return; ++ pr_warn("fi_mmapped wrapped around\n"); ++ while (!atomic_inc_return(&au_fi(f)->fi_mmapped)) ++ ; ++} ++ ++static inline void au_unset_mmapped(struct file *f) ++{ ++ atomic_dec(&au_fi(f)->fi_mmapped); ++} ++ ++static inline int au_test_mmapped(struct file *f) ++{ ++ return atomic_read(&au_fi(f)->fi_mmapped); ++} ++ ++/* customize vma->vm_file */ ++ ++static inline void au_do_vm_file_reset(struct vm_area_struct *vma, ++ struct file *file) ++{ ++ struct file *f; ++ ++ f = vma->vm_file; ++ get_file(file); ++ vma->vm_file = file; ++ fput(f); ++} ++ ++#ifdef CONFIG_MMU ++#define AuDbgVmRegion(file, vma) do {} while (0) ++ ++static inline void au_vm_file_reset(struct vm_area_struct *vma, ++ struct file *file) ++{ ++ au_do_vm_file_reset(vma, file); ++} ++#else ++#define AuDbgVmRegion(file, vma) \ ++ AuDebugOn((vma)->vm_region && (vma)->vm_region->vm_file != (file)) ++ ++static inline void au_vm_file_reset(struct vm_area_struct *vma, ++ struct file *file) ++{ ++ struct file *f; ++ ++ au_do_vm_file_reset(vma, file); ++ f = vma->vm_region->vm_file; ++ get_file(file); ++ vma->vm_region->vm_file = file; ++ fput(f); ++} ++#endif /* CONFIG_MMU */ ++ ++/* handle vma->vm_prfile */ ++static inline void au_vm_prfile_set(struct vm_area_struct *vma, ++ struct file *file) ++{ ++ get_file(file); ++ vma->vm_prfile = file; ++#ifndef CONFIG_MMU ++ get_file(file); ++ vma->vm_region->vm_prfile = file; ++#endif ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_FILE_H__ */ +diff --git a/fs/aufs/finfo.c b/fs/aufs/finfo.c +new file mode 100644 +index 000000000000..e2d6859850b6 +--- /dev/null ++++ b/fs/aufs/finfo.c +@@ -0,0 +1,136 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * file private data ++ */ ++ ++#include "aufs.h" ++ ++void au_hfput(struct au_hfile *hf, int execed) ++{ ++ if (execed) ++ allow_write_access(hf->hf_file); ++ fput(hf->hf_file); ++ hf->hf_file = NULL; ++ au_lcnt_dec(&hf->hf_br->br_nfiles); ++ hf->hf_br = NULL; ++} ++ ++void au_set_h_fptr(struct file *file, aufs_bindex_t bindex, struct file *val) ++{ ++ struct au_finfo *finfo = au_fi(file); ++ struct au_hfile *hf; ++ struct au_fidir *fidir; ++ ++ fidir = finfo->fi_hdir; ++ if (!fidir) { ++ AuDebugOn(finfo->fi_btop != bindex); ++ hf = &finfo->fi_htop; ++ } else ++ hf = fidir->fd_hfile + bindex; ++ ++ if (hf && hf->hf_file) ++ au_hfput(hf, vfsub_file_execed(file)); ++ if (val) { ++ FiMustWriteLock(file); ++ AuDebugOn(IS_ERR_OR_NULL(file->f_path.dentry)); ++ hf->hf_file = val; ++ hf->hf_br = au_sbr(file->f_path.dentry->d_sb, bindex); ++ } ++} ++ ++void au_update_figen(struct file *file) ++{ ++ atomic_set(&au_fi(file)->fi_generation, au_digen(file->f_path.dentry)); ++ /* smp_mb(); */ /* atomic_set */ ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_fidir *au_fidir_alloc(struct super_block *sb) ++{ ++ struct au_fidir *fidir; ++ int nbr; ++ ++ nbr = au_sbbot(sb) + 1; ++ if (nbr < 2) ++ nbr = 2; /* initial allocate for 2 branches */ ++ fidir = kzalloc(au_fidir_sz(nbr), GFP_NOFS); ++ if (fidir) { ++ fidir->fd_bbot = -1; ++ fidir->fd_nent = nbr; ++ } ++ ++ return fidir; ++} ++ ++int au_fidir_realloc(struct au_finfo *finfo, int nbr, int may_shrink) ++{ ++ int err; ++ struct au_fidir *fidir, *p; ++ ++ AuRwMustWriteLock(&finfo->fi_rwsem); ++ fidir = finfo->fi_hdir; ++ AuDebugOn(!fidir); ++ ++ err = -ENOMEM; ++ p = au_kzrealloc(fidir, au_fidir_sz(fidir->fd_nent), au_fidir_sz(nbr), ++ GFP_NOFS, may_shrink); ++ if (p) { ++ p->fd_nent = nbr; ++ finfo->fi_hdir = p; ++ err = 0; ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_finfo_fin(struct file *file) ++{ ++ struct au_finfo *finfo; ++ ++ au_lcnt_dec(&au_sbi(file->f_path.dentry->d_sb)->si_nfiles); ++ ++ finfo = au_fi(file); ++ AuDebugOn(finfo->fi_hdir); ++ AuRwDestroy(&finfo->fi_rwsem); ++ au_cache_free_finfo(finfo); ++} ++ ++void au_fi_init_once(void *_finfo) ++{ ++ struct au_finfo *finfo = _finfo; ++ ++ au_rw_init(&finfo->fi_rwsem); ++} ++ ++int au_finfo_init(struct file *file, struct au_fidir *fidir) ++{ ++ int err; ++ struct au_finfo *finfo; ++ struct dentry *dentry; ++ ++ err = -ENOMEM; ++ dentry = file->f_path.dentry; ++ finfo = au_cache_alloc_finfo(); ++ if (unlikely(!finfo)) ++ goto out; ++ ++ err = 0; ++ au_lcnt_inc(&au_sbi(dentry->d_sb)->si_nfiles); ++ au_rw_write_lock(&finfo->fi_rwsem); ++ finfo->fi_btop = -1; ++ finfo->fi_hdir = fidir; ++ atomic_set(&finfo->fi_generation, au_digen(dentry)); ++ /* smp_mb(); */ /* atomic_set */ ++ ++ file->private_data = finfo; ++ ++out: ++ return err; ++} +diff --git a/fs/aufs/fstype.h b/fs/aufs/fstype.h +new file mode 100644 +index 000000000000..7c001dae1859 +--- /dev/null ++++ b/fs/aufs/fstype.h +@@ -0,0 +1,388 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * judging filesystem type ++ */ ++ ++#ifndef __AUFS_FSTYPE_H__ ++#define __AUFS_FSTYPE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++#include ++#include ++ ++static inline int au_test_aufs(struct super_block *sb) ++{ ++ return sb->s_magic == AUFS_SUPER_MAGIC; ++} ++ ++static inline const char *au_sbtype(struct super_block *sb) ++{ ++ return sb->s_type->name; ++} ++ ++static inline int au_test_iso9660(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_ISO9660_FS) ++ return sb->s_magic == ISOFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_romfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_ROMFS_FS) ++ return sb->s_magic == ROMFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_cramfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_CRAMFS) ++ return sb->s_magic == CRAMFS_MAGIC; ++#endif ++ return 0; ++} ++ ++static inline int au_test_nfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_NFS_FS) ++ return sb->s_magic == NFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_fuse(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_FUSE_FS) ++ return sb->s_magic == FUSE_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_xfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_XFS_FS) ++ return sb->s_magic == XFS_SB_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_tmpfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_TMPFS ++ return sb->s_magic == TMPFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_ecryptfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_ECRYPT_FS) ++ return !strcmp(au_sbtype(sb), "ecryptfs"); ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_ramfs(struct super_block *sb) ++{ ++ return sb->s_magic == RAMFS_MAGIC; ++} ++ ++static inline int au_test_ubifs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_UBIFS_FS) ++ return sb->s_magic == UBIFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_procfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_PROC_FS ++ return sb->s_magic == PROC_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_sysfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_SYSFS ++ return sb->s_magic == SYSFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_configfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_CONFIGFS_FS) ++ return sb->s_magic == CONFIGFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_minix(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_MINIX_FS) ++ return sb->s_magic == MINIX3_SUPER_MAGIC ++ || sb->s_magic == MINIX2_SUPER_MAGIC ++ || sb->s_magic == MINIX2_SUPER_MAGIC2 ++ || sb->s_magic == MINIX_SUPER_MAGIC ++ || sb->s_magic == MINIX_SUPER_MAGIC2; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_fat(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_FAT_FS) ++ return sb->s_magic == MSDOS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_msdos(struct super_block *sb) ++{ ++ return au_test_fat(sb); ++} ++ ++static inline int au_test_vfat(struct super_block *sb) ++{ ++ return au_test_fat(sb); ++} ++ ++static inline int au_test_securityfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_SECURITYFS ++ return sb->s_magic == SECURITYFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_squashfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_SQUASHFS) ++ return sb->s_magic == SQUASHFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_btrfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_BTRFS_FS) ++ return sb->s_magic == BTRFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_xenfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_XENFS) ++ return sb->s_magic == XENFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_debugfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_DEBUG_FS ++ return sb->s_magic == DEBUGFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_nilfs(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_NILFS) ++ return sb->s_magic == NILFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_hfsplus(struct super_block *sb __maybe_unused) ++{ ++#if IS_ENABLED(CONFIG_HFSPLUS_FS) ++ return sb->s_magic == HFSPLUS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * they can't be an aufs branch. ++ */ ++static inline int au_test_fs_unsuppoted(struct super_block *sb) ++{ ++ return ++#ifndef CONFIG_AUFS_BR_RAMFS ++ au_test_ramfs(sb) || ++#endif ++ au_test_procfs(sb) ++ || au_test_sysfs(sb) ++ || au_test_configfs(sb) ++ || au_test_debugfs(sb) ++ || au_test_securityfs(sb) ++ || au_test_xenfs(sb) ++ || au_test_ecryptfs(sb) ++ /* || !strcmp(au_sbtype(sb), "unionfs") */ ++ || au_test_aufs(sb); /* will be supported in next version */ ++} ++ ++static inline int au_test_fs_remote(struct super_block *sb) ++{ ++ return !au_test_tmpfs(sb) ++#ifdef CONFIG_AUFS_BR_RAMFS ++ && !au_test_ramfs(sb) ++#endif ++ && !(sb->s_type->fs_flags & FS_REQUIRES_DEV); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * Note: these functions (below) are created after reading ->getattr() in all ++ * filesystems under linux/fs. it means we have to do so in every update... ++ */ ++ ++/* ++ * some filesystems require getattr to refresh the inode attributes before ++ * referencing. ++ * in most cases, we can rely on the inode attribute in NFS (or every remote fs) ++ * and leave the work for d_revalidate() ++ */ ++static inline int au_test_fs_refresh_iattr(struct super_block *sb) ++{ ++ return au_test_nfs(sb) ++ || au_test_fuse(sb) ++ /* || au_test_btrfs(sb) */ /* untested */ ++ ; ++} ++ ++/* ++ * filesystems which don't maintain i_size or i_blocks. ++ */ ++static inline int au_test_fs_bad_iattr_size(struct super_block *sb) ++{ ++ return au_test_xfs(sb) ++ || au_test_btrfs(sb) ++ || au_test_ubifs(sb) ++ || au_test_hfsplus(sb) /* maintained, but incorrect */ ++ /* || au_test_minix(sb) */ /* untested */ ++ ; ++} ++ ++/* ++ * filesystems which don't store the correct value in some of their inode ++ * attributes. ++ */ ++static inline int au_test_fs_bad_iattr(struct super_block *sb) ++{ ++ return au_test_fs_bad_iattr_size(sb) ++ || au_test_fat(sb) ++ || au_test_msdos(sb) ++ || au_test_vfat(sb); ++} ++ ++/* they don't check i_nlink in link(2) */ ++static inline int au_test_fs_no_limit_nlink(struct super_block *sb) ++{ ++ return au_test_tmpfs(sb) ++#ifdef CONFIG_AUFS_BR_RAMFS ++ || au_test_ramfs(sb) ++#endif ++ || au_test_ubifs(sb) ++ || au_test_hfsplus(sb); ++} ++ ++/* ++ * filesystems which sets S_NOATIME and S_NOCMTIME. ++ */ ++static inline int au_test_fs_notime(struct super_block *sb) ++{ ++ return au_test_nfs(sb) ++ || au_test_fuse(sb) ++ || au_test_ubifs(sb) ++ ; ++} ++ ++/* temporary support for i#1 in cramfs */ ++static inline int au_test_fs_unique_ino(struct inode *inode) ++{ ++ if (au_test_cramfs(inode->i_sb)) ++ return inode->i_ino != 1; ++ return 1; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * the filesystem where the xino files placed must support i/o after unlink and ++ * maintain i_size and i_blocks. ++ */ ++static inline int au_test_fs_bad_xino(struct super_block *sb) ++{ ++ return au_test_fs_remote(sb) ++ || au_test_fs_bad_iattr_size(sb) ++ /* don't want unnecessary work for xino */ ++ || au_test_aufs(sb) ++ || au_test_ecryptfs(sb) ++ || au_test_nilfs(sb); ++} ++ ++static inline int au_test_fs_trunc_xino(struct super_block *sb) ++{ ++ return au_test_tmpfs(sb) ++ || au_test_ramfs(sb); ++} ++ ++/* ++ * test if the @sb is real-readonly. ++ */ ++static inline int au_test_fs_rr(struct super_block *sb) ++{ ++ return au_test_squashfs(sb) ++ || au_test_iso9660(sb) ++ || au_test_cramfs(sb) ++ || au_test_romfs(sb); ++} ++ ++/* ++ * test if the @inode is nfs with 'noacl' option ++ * NFS always sets SB_POSIXACL regardless its mount option 'noacl.' ++ */ ++static inline int au_test_nfs_noacl(struct inode *inode) ++{ ++ return au_test_nfs(inode->i_sb) ++ /* && IS_POSIXACL(inode) */ ++ && !nfs_server_capable(inode, NFS_CAP_ACLS); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_FSTYPE_H__ */ +diff --git a/fs/aufs/hbl.h b/fs/aufs/hbl.h +new file mode 100644 +index 000000000000..571efb1e2300 +--- /dev/null ++++ b/fs/aufs/hbl.h +@@ -0,0 +1,52 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2017-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * helpers for hlist_bl.h ++ */ ++ ++#ifndef __AUFS_HBL_H__ ++#define __AUFS_HBL_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++ ++static inline void au_hbl_add(struct hlist_bl_node *node, ++ struct hlist_bl_head *hbl) ++{ ++ hlist_bl_lock(hbl); ++ hlist_bl_add_head(node, hbl); ++ hlist_bl_unlock(hbl); ++} ++ ++static inline void au_hbl_del(struct hlist_bl_node *node, ++ struct hlist_bl_head *hbl) ++{ ++ hlist_bl_lock(hbl); ++ hlist_bl_del(node); ++ hlist_bl_unlock(hbl); ++} ++ ++#define au_hbl_for_each(pos, head) \ ++ for (pos = hlist_bl_first(head); \ ++ pos; \ ++ pos = pos->next) ++ ++static inline unsigned long au_hbl_count(struct hlist_bl_head *hbl) ++{ ++ unsigned long cnt; ++ struct hlist_bl_node *pos; ++ ++ cnt = 0; ++ hlist_bl_lock(hbl); ++ au_hbl_for_each(pos, hbl) ++ cnt++; ++ hlist_bl_unlock(hbl); ++ return cnt; ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_HBL_H__ */ +diff --git a/fs/aufs/hfsnotify.c b/fs/aufs/hfsnotify.c +new file mode 100644 +index 000000000000..65acdd7f5b69 +--- /dev/null ++++ b/fs/aufs/hfsnotify.c +@@ -0,0 +1,275 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * fsnotify for the lower directories ++ */ ++ ++#include "aufs.h" ++ ++/* FS_IN_IGNORED is unnecessary */ ++static const __u32 AuHfsnMask = (FS_MOVED_TO | FS_MOVED_FROM | FS_DELETE ++ | FS_CREATE | FS_EVENT_ON_CHILD); ++static DECLARE_WAIT_QUEUE_HEAD(au_hfsn_wq); ++static __cacheline_aligned_in_smp atomic64_t au_hfsn_ifree = ATOMIC64_INIT(0); ++ ++static void au_hfsn_free_mark(struct fsnotify_mark *mark) ++{ ++ struct au_hnotify *hn = container_of(mark, struct au_hnotify, ++ hn_mark); ++ /* AuDbg("here\n"); */ ++ au_cache_free_hnotify(hn); ++ smp_mb__before_atomic(); /* for atomic64_dec */ ++ if (atomic64_dec_and_test(&au_hfsn_ifree)) ++ wake_up(&au_hfsn_wq); ++} ++ ++static int au_hfsn_alloc(struct au_hinode *hinode) ++{ ++ int err; ++ struct au_hnotify *hn; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct fsnotify_mark *mark; ++ aufs_bindex_t bindex; ++ ++ hn = hinode->hi_notify; ++ sb = hn->hn_aufs_inode->i_sb; ++ bindex = au_br_index(sb, hinode->hi_id); ++ br = au_sbr(sb, bindex); ++ AuDebugOn(!br->br_hfsn); ++ ++ mark = &hn->hn_mark; ++ fsnotify_init_mark(mark, br->br_hfsn->hfsn_group); ++ mark->mask = AuHfsnMask; ++ /* ++ * by udba rename or rmdir, aufs assign a new inode to the known ++ * h_inode, so specify 1 to allow dups. ++ */ ++ lockdep_off(); ++ err = fsnotify_add_inode_mark(mark, hinode->hi_inode, /*allow_dups*/1); ++ lockdep_on(); ++ ++ return err; ++} ++ ++static int au_hfsn_free(struct au_hinode *hinode, struct au_hnotify *hn) ++{ ++ struct fsnotify_mark *mark; ++ unsigned long long ull; ++ struct fsnotify_group *group; ++ ++ ull = atomic64_inc_return(&au_hfsn_ifree); ++ BUG_ON(!ull); ++ ++ mark = &hn->hn_mark; ++ spin_lock(&mark->lock); ++ group = mark->group; ++ fsnotify_get_group(group); ++ spin_unlock(&mark->lock); ++ lockdep_off(); ++ fsnotify_destroy_mark(mark, group); ++ fsnotify_put_mark(mark); ++ fsnotify_put_group(group); ++ lockdep_on(); ++ ++ /* free hn by myself */ ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_hfsn_ctl(struct au_hinode *hinode, int do_set) ++{ ++ struct fsnotify_mark *mark; ++ ++ mark = &hinode->hi_notify->hn_mark; ++ spin_lock(&mark->lock); ++ if (do_set) { ++ AuDebugOn(mark->mask & AuHfsnMask); ++ mark->mask |= AuHfsnMask; ++ } else { ++ AuDebugOn(!(mark->mask & AuHfsnMask)); ++ mark->mask &= ~AuHfsnMask; ++ } ++ spin_unlock(&mark->lock); ++ /* fsnotify_recalc_inode_mask(hinode->hi_inode); */ ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* #define AuDbgHnotify */ ++#ifdef AuDbgHnotify ++static char *au_hfsn_name(u32 mask) ++{ ++#ifdef CONFIG_AUFS_DEBUG ++#define test_ret(flag) \ ++ do { \ ++ if (mask & flag) \ ++ return #flag; \ ++ } while (0) ++ test_ret(FS_ACCESS); ++ test_ret(FS_MODIFY); ++ test_ret(FS_ATTRIB); ++ test_ret(FS_CLOSE_WRITE); ++ test_ret(FS_CLOSE_NOWRITE); ++ test_ret(FS_OPEN); ++ test_ret(FS_MOVED_FROM); ++ test_ret(FS_MOVED_TO); ++ test_ret(FS_CREATE); ++ test_ret(FS_DELETE); ++ test_ret(FS_DELETE_SELF); ++ test_ret(FS_MOVE_SELF); ++ test_ret(FS_UNMOUNT); ++ test_ret(FS_Q_OVERFLOW); ++ test_ret(FS_IN_IGNORED); ++ test_ret(FS_ISDIR); ++ test_ret(FS_IN_ONESHOT); ++ test_ret(FS_EVENT_ON_CHILD); ++ return ""; ++#undef test_ret ++#else ++ return "??"; ++#endif ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_hfsn_free_group(struct fsnotify_group *group) ++{ ++ struct au_br_hfsnotify *hfsn = group->private; ++ ++ /* AuDbg("here\n"); */ ++ au_kfree_try_rcu(hfsn); ++} ++ ++static int au_hfsn_handle_event(struct fsnotify_group *group, ++ struct inode *inode, ++ u32 mask, const void *data, int data_type, ++ const struct qstr *file_name, u32 cookie, ++ struct fsnotify_iter_info *iter_info) ++{ ++ int err; ++ struct au_hnotify *hnotify; ++ struct inode *h_dir, *h_inode; ++ struct fsnotify_mark *inode_mark; ++ ++ AuDebugOn(data_type != FSNOTIFY_EVENT_INODE); ++ ++ err = 0; ++ /* if FS_UNMOUNT happens, there must be another bug */ ++ AuDebugOn(mask & FS_UNMOUNT); ++ if (mask & (FS_IN_IGNORED | FS_UNMOUNT)) ++ goto out; ++ ++ h_dir = inode; ++ h_inode = NULL; ++#ifdef AuDbgHnotify ++ au_debug_on(); ++ if (1 || h_child_qstr.len != sizeof(AUFS_XINO_FNAME) - 1 ++ || strncmp(h_child_qstr.name, AUFS_XINO_FNAME, h_child_qstr.len)) { ++ AuDbg("i%lu, mask 0x%x %s, hcname %.*s, hi%lu\n", ++ h_dir->i_ino, mask, au_hfsn_name(mask), ++ AuLNPair(&h_child_qstr), h_inode ? h_inode->i_ino : 0); ++ /* WARN_ON(1); */ ++ } ++ au_debug_off(); ++#endif ++ ++ inode_mark = fsnotify_iter_inode_mark(iter_info); ++ AuDebugOn(!inode_mark); ++ hnotify = container_of(inode_mark, struct au_hnotify, hn_mark); ++ err = au_hnotify(h_dir, hnotify, mask, file_name, h_inode); ++ ++out: ++ return err; ++} ++ ++static struct fsnotify_ops au_hfsn_ops = { ++ .handle_event = au_hfsn_handle_event, ++ .free_group_priv = au_hfsn_free_group, ++ .free_mark = au_hfsn_free_mark ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_hfsn_fin_br(struct au_branch *br) ++{ ++ struct au_br_hfsnotify *hfsn; ++ ++ hfsn = br->br_hfsn; ++ if (hfsn) { ++ lockdep_off(); ++ fsnotify_put_group(hfsn->hfsn_group); ++ lockdep_on(); ++ } ++} ++ ++static int au_hfsn_init_br(struct au_branch *br, int perm) ++{ ++ int err; ++ struct fsnotify_group *group; ++ struct au_br_hfsnotify *hfsn; ++ ++ err = 0; ++ br->br_hfsn = NULL; ++ if (!au_br_hnotifyable(perm)) ++ goto out; ++ ++ err = -ENOMEM; ++ hfsn = kmalloc(sizeof(*hfsn), GFP_NOFS); ++ if (unlikely(!hfsn)) ++ goto out; ++ ++ err = 0; ++ group = fsnotify_alloc_group(&au_hfsn_ops); ++ if (IS_ERR(group)) { ++ err = PTR_ERR(group); ++ pr_err("fsnotify_alloc_group() failed, %d\n", err); ++ goto out_hfsn; ++ } ++ ++ group->private = hfsn; ++ hfsn->hfsn_group = group; ++ br->br_hfsn = hfsn; ++ goto out; /* success */ ++ ++out_hfsn: ++ au_kfree_try_rcu(hfsn); ++out: ++ return err; ++} ++ ++static int au_hfsn_reset_br(unsigned int udba, struct au_branch *br, int perm) ++{ ++ int err; ++ ++ err = 0; ++ if (!br->br_hfsn) ++ err = au_hfsn_init_br(br, perm); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_hfsn_fin(void) ++{ ++ AuDbg("au_hfsn_ifree %lld\n", (long long)atomic64_read(&au_hfsn_ifree)); ++ wait_event(au_hfsn_wq, !atomic64_read(&au_hfsn_ifree)); ++} ++ ++const struct au_hnotify_op au_hnotify_op = { ++ .ctl = au_hfsn_ctl, ++ .alloc = au_hfsn_alloc, ++ .free = au_hfsn_free, ++ ++ .fin = au_hfsn_fin, ++ ++ .reset_br = au_hfsn_reset_br, ++ .fin_br = au_hfsn_fin_br, ++ .init_br = au_hfsn_init_br ++}; +diff --git a/fs/aufs/hfsplus.c b/fs/aufs/hfsplus.c +new file mode 100644 +index 000000000000..3d4fed48bf16 +--- /dev/null ++++ b/fs/aufs/hfsplus.c +@@ -0,0 +1,47 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2010-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * special support for filesystems which acquires an inode mutex ++ * at final closing a file, eg, hfsplus. ++ * ++ * This trick is very simple and stupid, just to open the file before really ++ * necessary open to tell hfsplus that this is not the final closing. ++ * The caller should call au_h_open_pre() after acquiring the inode mutex, ++ * and au_h_open_post() after releasing it. ++ */ ++ ++#include "aufs.h" ++ ++struct file *au_h_open_pre(struct dentry *dentry, aufs_bindex_t bindex, ++ int force_wr) ++{ ++ struct file *h_file; ++ struct dentry *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ AuDebugOn(!h_dentry); ++ AuDebugOn(d_is_negative(h_dentry)); ++ ++ h_file = NULL; ++ if (au_test_hfsplus(h_dentry->d_sb) ++ && d_is_reg(h_dentry)) ++ h_file = au_h_open(dentry, bindex, ++ O_RDONLY | O_NOATIME | O_LARGEFILE, ++ /*file*/NULL, force_wr); ++ return h_file; ++} ++ ++void au_h_open_post(struct dentry *dentry, aufs_bindex_t bindex, ++ struct file *h_file) ++{ ++ struct au_branch *br; ++ ++ if (h_file) { ++ fput(h_file); ++ br = au_sbr(dentry->d_sb, bindex); ++ au_lcnt_dec(&br->br_nfiles); ++ } ++} +diff --git a/fs/aufs/hnotify.c b/fs/aufs/hnotify.c +new file mode 100644 +index 000000000000..e082f63ccaf9 +--- /dev/null ++++ b/fs/aufs/hnotify.c +@@ -0,0 +1,702 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * abstraction to notify the direct changes on lower directories ++ */ ++ ++/* #include */ ++#include "aufs.h" ++ ++int au_hn_alloc(struct au_hinode *hinode, struct inode *inode) ++{ ++ int err; ++ struct au_hnotify *hn; ++ ++ err = -ENOMEM; ++ hn = au_cache_alloc_hnotify(); ++ if (hn) { ++ hn->hn_aufs_inode = inode; ++ hinode->hi_notify = hn; ++ err = au_hnotify_op.alloc(hinode); ++ AuTraceErr(err); ++ if (unlikely(err)) { ++ hinode->hi_notify = NULL; ++ au_cache_free_hnotify(hn); ++ /* ++ * The upper dir was removed by udba, but the same named ++ * dir left. In this case, aufs assigns a new inode ++ * number and set the monitor again. ++ * For the lower dir, the old monitor is still left. ++ */ ++ if (err == -EEXIST) ++ err = 0; ++ } ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_hn_free(struct au_hinode *hinode) ++{ ++ struct au_hnotify *hn; ++ ++ hn = hinode->hi_notify; ++ if (hn) { ++ hinode->hi_notify = NULL; ++ if (au_hnotify_op.free(hinode, hn)) ++ au_cache_free_hnotify(hn); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_hn_ctl(struct au_hinode *hinode, int do_set) ++{ ++ if (hinode->hi_notify) ++ au_hnotify_op.ctl(hinode, do_set); ++} ++ ++void au_hn_reset(struct inode *inode, unsigned int flags) ++{ ++ aufs_bindex_t bindex, bbot; ++ struct inode *hi; ++ struct dentry *iwhdentry; ++ ++ bbot = au_ibbot(inode); ++ for (bindex = au_ibtop(inode); bindex <= bbot; bindex++) { ++ hi = au_h_iptr(inode, bindex); ++ if (!hi) ++ continue; ++ ++ /* inode_lock_nested(hi, AuLsc_I_CHILD); */ ++ iwhdentry = au_hi_wh(inode, bindex); ++ if (iwhdentry) ++ dget(iwhdentry); ++ au_igrab(hi); ++ au_set_h_iptr(inode, bindex, NULL, 0); ++ au_set_h_iptr(inode, bindex, au_igrab(hi), ++ flags & ~AuHi_XINO); ++ iput(hi); ++ dput(iwhdentry); ++ /* inode_unlock(hi); */ ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int hn_xino(struct inode *inode, struct inode *h_inode) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot, bfound, btop; ++ struct inode *h_i; ++ ++ err = 0; ++ if (unlikely(inode->i_ino == AUFS_ROOT_INO)) { ++ pr_warn("branch root dir was changed\n"); ++ goto out; ++ } ++ ++ bfound = -1; ++ bbot = au_ibbot(inode); ++ btop = au_ibtop(inode); ++#if 0 /* reserved for future use */ ++ if (bindex == bbot) { ++ /* keep this ino in rename case */ ++ goto out; ++ } ++#endif ++ for (bindex = btop; bindex <= bbot; bindex++) ++ if (au_h_iptr(inode, bindex) == h_inode) { ++ bfound = bindex; ++ break; ++ } ++ if (bfound < 0) ++ goto out; ++ ++ for (bindex = btop; bindex <= bbot; bindex++) { ++ h_i = au_h_iptr(inode, bindex); ++ if (!h_i) ++ continue; ++ ++ err = au_xino_write(inode->i_sb, bindex, h_i->i_ino, /*ino*/0); ++ /* ignore this error */ ++ /* bad action? */ ++ } ++ ++ /* children inode number will be broken */ ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int hn_gen_tree(struct dentry *dentry) ++{ ++ int err, i, j, ndentry; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_dcsub_pages(&dpages, dentry, NULL, NULL); ++ if (unlikely(err)) ++ goto out_dpages; ++ ++ for (i = 0; i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ ndentry = dpage->ndentry; ++ for (j = 0; j < ndentry; j++) { ++ struct dentry *d; ++ ++ d = dentries[j]; ++ if (IS_ROOT(d)) ++ continue; ++ ++ au_digen_dec(d); ++ if (d_really_is_positive(d)) ++ /* todo: reset children xino? ++ cached children only? */ ++ au_iigen_dec(d_inode(d)); ++ } ++ } ++ ++out_dpages: ++ au_dpages_free(&dpages); ++out: ++ return err; ++} ++ ++/* ++ * return 0 if processed. ++ */ ++static int hn_gen_by_inode(char *name, unsigned int nlen, struct inode *inode, ++ const unsigned int isdir) ++{ ++ int err; ++ struct dentry *d; ++ struct qstr *dname; ++ ++ err = 1; ++ if (unlikely(inode->i_ino == AUFS_ROOT_INO)) { ++ pr_warn("branch root dir was changed\n"); ++ err = 0; ++ goto out; ++ } ++ ++ if (!isdir) { ++ AuDebugOn(!name); ++ au_iigen_dec(inode); ++ spin_lock(&inode->i_lock); ++ hlist_for_each_entry(d, &inode->i_dentry, d_u.d_alias) { ++ spin_lock(&d->d_lock); ++ dname = &d->d_name; ++ if (dname->len != nlen ++ && memcmp(dname->name, name, nlen)) { ++ spin_unlock(&d->d_lock); ++ continue; ++ } ++ err = 0; ++ au_digen_dec(d); ++ spin_unlock(&d->d_lock); ++ break; ++ } ++ spin_unlock(&inode->i_lock); ++ } else { ++ au_fset_si(au_sbi(inode->i_sb), FAILED_REFRESH_DIR); ++ d = d_find_any_alias(inode); ++ if (!d) { ++ au_iigen_dec(inode); ++ goto out; ++ } ++ ++ spin_lock(&d->d_lock); ++ dname = &d->d_name; ++ if (dname->len == nlen && !memcmp(dname->name, name, nlen)) { ++ spin_unlock(&d->d_lock); ++ err = hn_gen_tree(d); ++ spin_lock(&d->d_lock); ++ } ++ spin_unlock(&d->d_lock); ++ dput(d); ++ } ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int hn_gen_by_name(struct dentry *dentry, const unsigned int isdir) ++{ ++ int err; ++ ++ if (IS_ROOT(dentry)) { ++ pr_warn("branch root dir was changed\n"); ++ return 0; ++ } ++ ++ err = 0; ++ if (!isdir) { ++ au_digen_dec(dentry); ++ if (d_really_is_positive(dentry)) ++ au_iigen_dec(d_inode(dentry)); ++ } else { ++ au_fset_si(au_sbi(dentry->d_sb), FAILED_REFRESH_DIR); ++ if (d_really_is_positive(dentry)) ++ err = hn_gen_tree(dentry); ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* hnotify job flags */ ++#define AuHnJob_XINO0 1 ++#define AuHnJob_GEN (1 << 1) ++#define AuHnJob_DIRENT (1 << 2) ++#define AuHnJob_ISDIR (1 << 3) ++#define AuHnJob_TRYXINO0 (1 << 4) ++#define AuHnJob_MNTPNT (1 << 5) ++#define au_ftest_hnjob(flags, name) ((flags) & AuHnJob_##name) ++#define au_fset_hnjob(flags, name) \ ++ do { (flags) |= AuHnJob_##name; } while (0) ++#define au_fclr_hnjob(flags, name) \ ++ do { (flags) &= ~AuHnJob_##name; } while (0) ++ ++enum { ++ AuHn_CHILD, ++ AuHn_PARENT, ++ AuHnLast ++}; ++ ++struct au_hnotify_args { ++ struct inode *h_dir, *dir, *h_child_inode; ++ u32 mask; ++ unsigned int flags[AuHnLast]; ++ unsigned int h_child_nlen; ++ char h_child_name[]; ++}; ++ ++struct hn_job_args { ++ unsigned int flags; ++ struct inode *inode, *h_inode, *dir, *h_dir; ++ struct dentry *dentry; ++ char *h_name; ++ int h_nlen; ++}; ++ ++static int hn_job(struct hn_job_args *a) ++{ ++ const unsigned int isdir = au_ftest_hnjob(a->flags, ISDIR); ++ int e; ++ ++ /* reset xino */ ++ if (au_ftest_hnjob(a->flags, XINO0) && a->inode) ++ hn_xino(a->inode, a->h_inode); /* ignore this error */ ++ ++ if (au_ftest_hnjob(a->flags, TRYXINO0) ++ && a->inode ++ && a->h_inode) { ++ inode_lock_shared_nested(a->h_inode, AuLsc_I_CHILD); ++ if (!a->h_inode->i_nlink ++ && !(a->h_inode->i_state & I_LINKABLE)) ++ hn_xino(a->inode, a->h_inode); /* ignore this error */ ++ inode_unlock_shared(a->h_inode); ++ } ++ ++ /* make the generation obsolete */ ++ if (au_ftest_hnjob(a->flags, GEN)) { ++ e = -1; ++ if (a->inode) ++ e = hn_gen_by_inode(a->h_name, a->h_nlen, a->inode, ++ isdir); ++ if (e && a->dentry) ++ hn_gen_by_name(a->dentry, isdir); ++ /* ignore this error */ ++ } ++ ++ /* make dir entries obsolete */ ++ if (au_ftest_hnjob(a->flags, DIRENT) && a->inode) { ++ struct au_vdir *vdir; ++ ++ vdir = au_ivdir(a->inode); ++ if (vdir) ++ vdir->vd_jiffy = 0; ++ /* IMustLock(a->inode); */ ++ /* inode_inc_iversion(a->inode); */ ++ } ++ ++ /* can do nothing but warn */ ++ if (au_ftest_hnjob(a->flags, MNTPNT) ++ && a->dentry ++ && d_mountpoint(a->dentry)) ++ pr_warn("mount-point %pd is removed or renamed\n", a->dentry); ++ ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry *lookup_wlock_by_name(char *name, unsigned int nlen, ++ struct inode *dir) ++{ ++ struct dentry *dentry, *d, *parent; ++ struct qstr *dname; ++ ++ parent = d_find_any_alias(dir); ++ if (!parent) ++ return NULL; ++ ++ dentry = NULL; ++ spin_lock(&parent->d_lock); ++ list_for_each_entry(d, &parent->d_subdirs, d_child) { ++ /* AuDbg("%pd\n", d); */ ++ spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED); ++ dname = &d->d_name; ++ if (dname->len != nlen || memcmp(dname->name, name, nlen)) ++ goto cont_unlock; ++ if (au_di(d)) ++ au_digen_dec(d); ++ else ++ goto cont_unlock; ++ if (au_dcount(d) > 0) { ++ dentry = dget_dlock(d); ++ spin_unlock(&d->d_lock); ++ break; ++ } ++ ++cont_unlock: ++ spin_unlock(&d->d_lock); ++ } ++ spin_unlock(&parent->d_lock); ++ dput(parent); ++ ++ if (dentry) ++ di_write_lock_child(dentry); ++ ++ return dentry; ++} ++ ++static struct inode *lookup_wlock_by_ino(struct super_block *sb, ++ aufs_bindex_t bindex, ino_t h_ino) ++{ ++ struct inode *inode; ++ ino_t ino; ++ int err; ++ ++ inode = NULL; ++ err = au_xino_read(sb, bindex, h_ino, &ino); ++ if (!err && ino) ++ inode = ilookup(sb, ino); ++ if (!inode) ++ goto out; ++ ++ if (unlikely(inode->i_ino == AUFS_ROOT_INO)) { ++ pr_warn("wrong root branch\n"); ++ iput(inode); ++ inode = NULL; ++ goto out; ++ } ++ ++ ii_write_lock_child(inode); ++ ++out: ++ return inode; ++} ++ ++static void au_hn_bh(void *_args) ++{ ++ struct au_hnotify_args *a = _args; ++ struct super_block *sb; ++ aufs_bindex_t bindex, bbot, bfound; ++ unsigned char xino, try_iput; ++ int err; ++ struct inode *inode; ++ ino_t h_ino; ++ struct hn_job_args args; ++ struct dentry *dentry; ++ struct au_sbinfo *sbinfo; ++ ++ AuDebugOn(!_args); ++ AuDebugOn(!a->h_dir); ++ AuDebugOn(!a->dir); ++ AuDebugOn(!a->mask); ++ AuDbg("mask 0x%x, i%lu, hi%lu, hci%lu\n", ++ a->mask, a->dir->i_ino, a->h_dir->i_ino, ++ a->h_child_inode ? a->h_child_inode->i_ino : 0); ++ ++ inode = NULL; ++ dentry = NULL; ++ /* ++ * do not lock a->dir->i_mutex here ++ * because of d_revalidate() may cause a deadlock. ++ */ ++ sb = a->dir->i_sb; ++ AuDebugOn(!sb); ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!sbinfo); ++ si_write_lock(sb, AuLock_NOPLMW); ++ ++ if (au_opt_test(sbinfo->si_mntflags, DIRREN)) ++ switch (a->mask & FS_EVENTS_POSS_ON_CHILD) { ++ case FS_MOVED_FROM: ++ case FS_MOVED_TO: ++ AuWarn1("DIRREN with UDBA may not work correctly " ++ "for the direct rename(2)\n"); ++ } ++ ++ ii_read_lock_parent(a->dir); ++ bfound = -1; ++ bbot = au_ibbot(a->dir); ++ for (bindex = au_ibtop(a->dir); bindex <= bbot; bindex++) ++ if (au_h_iptr(a->dir, bindex) == a->h_dir) { ++ bfound = bindex; ++ break; ++ } ++ ii_read_unlock(a->dir); ++ if (unlikely(bfound < 0)) ++ goto out; ++ ++ xino = !!au_opt_test(au_mntflags(sb), XINO); ++ h_ino = 0; ++ if (a->h_child_inode) ++ h_ino = a->h_child_inode->i_ino; ++ ++ if (a->h_child_nlen ++ && (au_ftest_hnjob(a->flags[AuHn_CHILD], GEN) ++ || au_ftest_hnjob(a->flags[AuHn_CHILD], MNTPNT))) ++ dentry = lookup_wlock_by_name(a->h_child_name, a->h_child_nlen, ++ a->dir); ++ try_iput = 0; ++ if (dentry && d_really_is_positive(dentry)) ++ inode = d_inode(dentry); ++ if (xino && !inode && h_ino ++ && (au_ftest_hnjob(a->flags[AuHn_CHILD], XINO0) ++ || au_ftest_hnjob(a->flags[AuHn_CHILD], TRYXINO0) ++ || au_ftest_hnjob(a->flags[AuHn_CHILD], GEN))) { ++ inode = lookup_wlock_by_ino(sb, bfound, h_ino); ++ try_iput = 1; ++ } ++ ++ args.flags = a->flags[AuHn_CHILD]; ++ args.dentry = dentry; ++ args.inode = inode; ++ args.h_inode = a->h_child_inode; ++ args.dir = a->dir; ++ args.h_dir = a->h_dir; ++ args.h_name = a->h_child_name; ++ args.h_nlen = a->h_child_nlen; ++ err = hn_job(&args); ++ if (dentry) { ++ if (au_di(dentry)) ++ di_write_unlock(dentry); ++ dput(dentry); ++ } ++ if (inode && try_iput) { ++ ii_write_unlock(inode); ++ iput(inode); ++ } ++ ++ ii_write_lock_parent(a->dir); ++ args.flags = a->flags[AuHn_PARENT]; ++ args.dentry = NULL; ++ args.inode = a->dir; ++ args.h_inode = a->h_dir; ++ args.dir = NULL; ++ args.h_dir = NULL; ++ args.h_name = NULL; ++ args.h_nlen = 0; ++ err = hn_job(&args); ++ ii_write_unlock(a->dir); ++ ++out: ++ iput(a->h_child_inode); ++ iput(a->h_dir); ++ iput(a->dir); ++ si_write_unlock(sb); ++ au_nwt_done(&sbinfo->si_nowait); ++ au_kfree_rcu(a); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_hnotify(struct inode *h_dir, struct au_hnotify *hnotify, u32 mask, ++ const struct qstr *h_child_qstr, struct inode *h_child_inode) ++{ ++ int err, len; ++ unsigned int flags[AuHnLast], f; ++ unsigned char isdir, isroot, wh; ++ struct inode *dir; ++ struct au_hnotify_args *args; ++ char *p, *h_child_name; ++ ++ err = 0; ++ AuDebugOn(!hnotify || !hnotify->hn_aufs_inode); ++ dir = igrab(hnotify->hn_aufs_inode); ++ if (!dir) ++ goto out; ++ ++ isroot = (dir->i_ino == AUFS_ROOT_INO); ++ wh = 0; ++ h_child_name = (void *)h_child_qstr->name; ++ len = h_child_qstr->len; ++ if (h_child_name) { ++ if (len > AUFS_WH_PFX_LEN ++ && !memcmp(h_child_name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) { ++ h_child_name += AUFS_WH_PFX_LEN; ++ len -= AUFS_WH_PFX_LEN; ++ wh = 1; ++ } ++ } ++ ++ isdir = 0; ++ if (h_child_inode) ++ isdir = !!S_ISDIR(h_child_inode->i_mode); ++ flags[AuHn_PARENT] = AuHnJob_ISDIR; ++ flags[AuHn_CHILD] = 0; ++ if (isdir) ++ flags[AuHn_CHILD] = AuHnJob_ISDIR; ++ au_fset_hnjob(flags[AuHn_PARENT], DIRENT); ++ au_fset_hnjob(flags[AuHn_CHILD], GEN); ++ switch (mask & ALL_FSNOTIFY_DIRENT_EVENTS) { ++ case FS_MOVED_FROM: ++ case FS_MOVED_TO: ++ au_fset_hnjob(flags[AuHn_CHILD], XINO0); ++ au_fset_hnjob(flags[AuHn_CHILD], MNTPNT); ++ /*FALLTHROUGH*/ ++ case FS_CREATE: ++ AuDebugOn(!h_child_name); ++ break; ++ ++ case FS_DELETE: ++ /* ++ * aufs never be able to get this child inode. ++ * revalidation should be in d_revalidate() ++ * by checking i_nlink, i_generation or d_unhashed(). ++ */ ++ AuDebugOn(!h_child_name); ++ au_fset_hnjob(flags[AuHn_CHILD], TRYXINO0); ++ au_fset_hnjob(flags[AuHn_CHILD], MNTPNT); ++ break; ++ ++ default: ++ AuDebugOn(1); ++ } ++ ++ if (wh) ++ h_child_inode = NULL; ++ ++ err = -ENOMEM; ++ /* iput() and kfree() will be called in au_hnotify() */ ++ args = kmalloc(sizeof(*args) + len + 1, GFP_NOFS); ++ if (unlikely(!args)) { ++ AuErr1("no memory\n"); ++ iput(dir); ++ goto out; ++ } ++ args->flags[AuHn_PARENT] = flags[AuHn_PARENT]; ++ args->flags[AuHn_CHILD] = flags[AuHn_CHILD]; ++ args->mask = mask; ++ args->dir = dir; ++ args->h_dir = igrab(h_dir); ++ if (h_child_inode) ++ h_child_inode = igrab(h_child_inode); /* can be NULL */ ++ args->h_child_inode = h_child_inode; ++ args->h_child_nlen = len; ++ if (len) { ++ p = (void *)args; ++ p += sizeof(*args); ++ memcpy(p, h_child_name, len); ++ p[len] = 0; ++ } ++ ++ /* NFS fires the event for silly-renamed one from kworker */ ++ f = 0; ++ if (!dir->i_nlink ++ || (au_test_nfs(h_dir->i_sb) && (mask & FS_DELETE))) ++ f = AuWkq_NEST; ++ err = au_wkq_nowait(au_hn_bh, args, dir->i_sb, f); ++ if (unlikely(err)) { ++ pr_err("wkq %d\n", err); ++ iput(args->h_child_inode); ++ iput(args->h_dir); ++ iput(args->dir); ++ au_kfree_rcu(args); ++ } ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_hnotify_reset_br(unsigned int udba, struct au_branch *br, int perm) ++{ ++ int err; ++ ++ AuDebugOn(!(udba & AuOptMask_UDBA)); ++ ++ err = 0; ++ if (au_hnotify_op.reset_br) ++ err = au_hnotify_op.reset_br(udba, br, perm); ++ ++ return err; ++} ++ ++int au_hnotify_init_br(struct au_branch *br, int perm) ++{ ++ int err; ++ ++ err = 0; ++ if (au_hnotify_op.init_br) ++ err = au_hnotify_op.init_br(br, perm); ++ ++ return err; ++} ++ ++void au_hnotify_fin_br(struct au_branch *br) ++{ ++ if (au_hnotify_op.fin_br) ++ au_hnotify_op.fin_br(br); ++} ++ ++static void au_hn_destroy_cache(void) ++{ ++ kmem_cache_destroy(au_cache[AuCache_HNOTIFY]); ++ au_cache[AuCache_HNOTIFY] = NULL; ++} ++ ++int __init au_hnotify_init(void) ++{ ++ int err; ++ ++ err = -ENOMEM; ++ au_cache[AuCache_HNOTIFY] = AuCache(au_hnotify); ++ if (au_cache[AuCache_HNOTIFY]) { ++ err = 0; ++ if (au_hnotify_op.init) ++ err = au_hnotify_op.init(); ++ if (unlikely(err)) ++ au_hn_destroy_cache(); ++ } ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_hnotify_fin(void) ++{ ++ if (au_hnotify_op.fin) ++ au_hnotify_op.fin(); ++ ++ /* cf. au_cache_fin() */ ++ if (au_cache[AuCache_HNOTIFY]) ++ au_hn_destroy_cache(); ++} +diff --git a/fs/aufs/i_op.c b/fs/aufs/i_op.c +new file mode 100644 +index 000000000000..42bc497e2630 +--- /dev/null ++++ b/fs/aufs/i_op.c +@@ -0,0 +1,1489 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * inode operations (except add/del/rename) ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include "aufs.h" ++ ++static int h_permission(struct inode *h_inode, int mask, ++ struct path *h_path, int brperm) ++{ ++ int err; ++ const unsigned char write_mask = !!(mask & (MAY_WRITE | MAY_APPEND)); ++ ++ err = -EPERM; ++ if (write_mask && IS_IMMUTABLE(h_inode)) ++ goto out; ++ ++ err = -EACCES; ++ if (((mask & MAY_EXEC) ++ && S_ISREG(h_inode->i_mode) ++ && (path_noexec(h_path) ++ || !(h_inode->i_mode & 0111)))) ++ goto out; ++ ++ /* ++ * - skip the lower fs test in the case of write to ro branch. ++ * - nfs dir permission write check is optimized, but a policy for ++ * link/rename requires a real check. ++ * - nfs always sets SB_POSIXACL regardless its mount option 'noacl.' ++ * in this case, generic_permission() returns -EOPNOTSUPP. ++ */ ++ if ((write_mask && !au_br_writable(brperm)) ++ || (au_test_nfs(h_inode->i_sb) && S_ISDIR(h_inode->i_mode) ++ && write_mask && !(mask & MAY_READ)) ++ || !h_inode->i_op->permission) { ++ /* AuLabel(generic_permission); */ ++ /* AuDbg("get_acl %ps\n", h_inode->i_op->get_acl); */ ++ err = generic_permission(h_inode, mask); ++ if (err == -EOPNOTSUPP && au_test_nfs_noacl(h_inode)) ++ err = h_inode->i_op->permission(h_inode, mask); ++ AuTraceErr(err); ++ } else { ++ /* AuLabel(h_inode->permission); */ ++ err = h_inode->i_op->permission(h_inode, mask); ++ AuTraceErr(err); ++ } ++ ++ if (!err) ++ err = devcgroup_inode_permission(h_inode, mask); ++ if (!err) ++ err = security_inode_permission(h_inode, mask); ++ ++out: ++ return err; ++} ++ ++static int aufs_permission(struct inode *inode, int mask) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ const unsigned char isdir = !!S_ISDIR(inode->i_mode), ++ write_mask = !!(mask & (MAY_WRITE | MAY_APPEND)); ++ struct inode *h_inode; ++ struct super_block *sb; ++ struct au_branch *br; ++ ++ /* todo: support rcu-walk? */ ++ if (mask & MAY_NOT_BLOCK) ++ return -ECHILD; ++ ++ sb = inode->i_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ ii_read_lock_child(inode); ++#if 0 /* reserved for future use */ ++ /* ++ * This test may be rather 'too much' since the test is essentially done ++ * in the aufs_lookup(). Theoretically it is possible that the inode ++ * generation doesn't match to the superblock's here. But it isn't a ++ * big deal I suppose. ++ */ ++ err = au_iigen_test(inode, au_sigen(sb)); ++ if (unlikely(err)) ++ goto out; ++#endif ++ ++ if (!isdir ++ || write_mask ++ || au_opt_test(au_mntflags(sb), DIRPERM1)) { ++ err = au_busy_or_stale(); ++ h_inode = au_h_iptr(inode, au_ibtop(inode)); ++ if (unlikely(!h_inode ++ || (h_inode->i_mode & S_IFMT) ++ != (inode->i_mode & S_IFMT))) ++ goto out; ++ ++ err = 0; ++ bindex = au_ibtop(inode); ++ br = au_sbr(sb, bindex); ++ err = h_permission(h_inode, mask, &br->br_path, br->br_perm); ++ if (write_mask ++ && !err ++ && !special_file(h_inode->i_mode)) { ++ /* test whether the upper writable branch exists */ ++ err = -EROFS; ++ for (; bindex >= 0; bindex--) ++ if (!au_br_rdonly(au_sbr(sb, bindex))) { ++ err = 0; ++ break; ++ } ++ } ++ goto out; ++ } ++ ++ /* non-write to dir */ ++ err = 0; ++ bbot = au_ibbot(inode); ++ for (bindex = au_ibtop(inode); !err && bindex <= bbot; bindex++) { ++ h_inode = au_h_iptr(inode, bindex); ++ if (h_inode) { ++ err = au_busy_or_stale(); ++ if (unlikely(!S_ISDIR(h_inode->i_mode))) ++ break; ++ ++ br = au_sbr(sb, bindex); ++ err = h_permission(h_inode, mask, &br->br_path, ++ br->br_perm); ++ } ++ } ++ ++out: ++ ii_read_unlock(inode); ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry *aufs_lookup(struct inode *dir, struct dentry *dentry, ++ unsigned int flags) ++{ ++ struct dentry *ret, *parent; ++ struct inode *inode; ++ struct super_block *sb; ++ int err, npositive; ++ ++ IMustLock(dir); ++ ++ /* todo: support rcu-walk? */ ++ ret = ERR_PTR(-ECHILD); ++ if (flags & LOOKUP_RCU) ++ goto out; ++ ++ ret = ERR_PTR(-ENAMETOOLONG); ++ if (unlikely(dentry->d_name.len > AUFS_MAX_NAMELEN)) ++ goto out; ++ ++ sb = dir->i_sb; ++ err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ ret = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_di_init(dentry); ++ ret = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_si; ++ ++ inode = NULL; ++ npositive = 0; /* suppress a warning */ ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_read_lock_parent(parent, AuLock_IR); ++ err = au_alive_dir(parent); ++ if (!err) ++ err = au_digen_test(parent, au_sigen(sb)); ++ if (!err) { ++ /* regardless LOOKUP_CREATE, always ALLOW_NEG */ ++ npositive = au_lkup_dentry(dentry, au_dbtop(parent), ++ AuLkup_ALLOW_NEG); ++ err = npositive; ++ } ++ di_read_unlock(parent, AuLock_IR); ++ ret = ERR_PTR(err); ++ if (unlikely(err < 0)) ++ goto out_unlock; ++ ++ if (npositive) { ++ inode = au_new_inode(dentry, /*must_new*/0); ++ if (IS_ERR(inode)) { ++ ret = (void *)inode; ++ inode = NULL; ++ goto out_unlock; ++ } ++ } ++ ++ if (inode) ++ atomic_inc(&inode->i_count); ++ ret = d_splice_alias(inode, dentry); ++#if 0 /* reserved for future use */ ++ if (unlikely(d_need_lookup(dentry))) { ++ spin_lock(&dentry->d_lock); ++ dentry->d_flags &= ~DCACHE_NEED_LOOKUP; ++ spin_unlock(&dentry->d_lock); ++ } else ++#endif ++ if (inode) { ++ if (!IS_ERR(ret)) { ++ iput(inode); ++ if (ret && ret != dentry) ++ ii_write_unlock(inode); ++ } else { ++ ii_write_unlock(inode); ++ iput(inode); ++ inode = NULL; ++ } ++ } ++ ++out_unlock: ++ di_write_unlock(dentry); ++out_si: ++ si_read_unlock(sb); ++out: ++ return ret; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * very dirty and complicated aufs ->atomic_open(). ++ * aufs_atomic_open() ++ * + au_aopen_or_create() ++ * + add_simple() ++ * + vfsub_atomic_open() ++ * + branch fs ->atomic_open() ++ * may call the actual 'open' for h_file ++ * + inc br_nfiles only if opened ++ * + au_aopen_no_open() or au_aopen_do_open() ++ * ++ * au_aopen_do_open() ++ * + finish_open() ++ * + au_do_aopen() ++ * + au_do_open() the body of all 'open' ++ * + au_do_open_nondir() ++ * set the passed h_file ++ * ++ * au_aopen_no_open() ++ * + finish_no_open() ++ */ ++ ++struct aopen_node { ++ struct hlist_bl_node hblist; ++ struct file *file, *h_file; ++}; ++ ++static int au_do_aopen(struct inode *inode, struct file *file) ++{ ++ struct hlist_bl_head *aopen; ++ struct hlist_bl_node *pos; ++ struct aopen_node *node; ++ struct au_do_open_args args = { ++ .aopen = 1, ++ .open = au_do_open_nondir ++ }; ++ ++ aopen = &au_sbi(inode->i_sb)->si_aopen; ++ hlist_bl_lock(aopen); ++ hlist_bl_for_each_entry(node, pos, aopen, hblist) ++ if (node->file == file) { ++ args.h_file = node->h_file; ++ break; ++ } ++ hlist_bl_unlock(aopen); ++ /* AuDebugOn(!args.h_file); */ ++ ++ return au_do_open(file, &args); ++} ++ ++static int au_aopen_do_open(struct file *file, struct dentry *dentry, ++ struct aopen_node *aopen_node) ++{ ++ int err; ++ struct hlist_bl_head *aopen; ++ ++ AuLabel(here); ++ aopen = &au_sbi(dentry->d_sb)->si_aopen; ++ au_hbl_add(&aopen_node->hblist, aopen); ++ err = finish_open(file, dentry, au_do_aopen); ++ au_hbl_del(&aopen_node->hblist, aopen); ++ /* AuDbgFile(file); */ ++ AuDbg("%pd%s%s\n", dentry, ++ (file->f_mode & FMODE_CREATED) ? " created" : "", ++ (file->f_mode & FMODE_OPENED) ? " opened" : ""); ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_aopen_no_open(struct file *file, struct dentry *dentry) ++{ ++ int err; ++ ++ AuLabel(here); ++ dget(dentry); ++ err = finish_no_open(file, dentry); ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++static int aufs_atomic_open(struct inode *dir, struct dentry *dentry, ++ struct file *file, unsigned int open_flag, ++ umode_t create_mode) ++{ ++ int err, did_open; ++ unsigned int lkup_flags; ++ aufs_bindex_t bindex; ++ struct super_block *sb; ++ struct dentry *parent, *d; ++ struct vfsub_aopen_args args = { ++ .open_flag = open_flag, ++ .create_mode = create_mode ++ }; ++ struct aopen_node aopen_node = { ++ .file = file ++ }; ++ ++ IMustLock(dir); ++ AuDbg("open_flag 0%o\n", open_flag); ++ AuDbgDentry(dentry); ++ ++ err = 0; ++ if (!au_di(dentry)) { ++ lkup_flags = LOOKUP_OPEN; ++ if (open_flag & O_CREAT) ++ lkup_flags |= LOOKUP_CREATE; ++ d = aufs_lookup(dir, dentry, lkup_flags); ++ if (IS_ERR(d)) { ++ err = PTR_ERR(d); ++ AuTraceErr(err); ++ goto out; ++ } else if (d) { ++ /* ++ * obsoleted dentry found. ++ * another error will be returned later. ++ */ ++ d_drop(d); ++ AuDbgDentry(d); ++ dput(d); ++ } ++ AuDbgDentry(dentry); ++ } ++ ++ if (d_is_positive(dentry) ++ || d_unhashed(dentry) ++ || d_unlinked(dentry) ++ || !(open_flag & O_CREAT)) { ++ err = au_aopen_no_open(file, dentry); ++ goto out; /* success */ ++ } ++ ++ err = aufs_read_lock(dentry, AuLock_DW | AuLock_FLUSH | AuLock_GEN); ++ if (unlikely(err)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ parent = dentry->d_parent; /* dir is locked */ ++ di_write_lock_parent(parent); ++ err = au_lkup_dentry(dentry, /*btop*/0, AuLkup_ALLOW_NEG); ++ if (unlikely(err < 0)) ++ goto out_parent; ++ ++ AuDbgDentry(dentry); ++ if (d_is_positive(dentry)) { ++ err = au_aopen_no_open(file, dentry); ++ goto out_parent; /* success */ ++ } ++ ++ args.file = alloc_empty_file(file->f_flags, current_cred()); ++ err = PTR_ERR(args.file); ++ if (IS_ERR(args.file)) ++ goto out_parent; ++ ++ bindex = au_dbtop(dentry); ++ err = au_aopen_or_create(dir, dentry, &args); ++ AuTraceErr(err); ++ AuDbgFile(args.file); ++ file->f_mode = args.file->f_mode & ~FMODE_OPENED; ++ did_open = !!(args.file->f_mode & FMODE_OPENED); ++ if (!did_open) { ++ fput(args.file); ++ args.file = NULL; ++ } ++ di_write_unlock(parent); ++ di_write_unlock(dentry); ++ if (unlikely(err < 0)) { ++ if (args.file) ++ fput(args.file); ++ goto out_sb; ++ } ++ ++ if (!did_open) ++ err = au_aopen_no_open(file, dentry); ++ else { ++ aopen_node.h_file = args.file; ++ err = au_aopen_do_open(file, dentry, &aopen_node); ++ } ++ if (unlikely(err < 0)) { ++ if (args.file) ++ fput(args.file); ++ if (did_open) ++ au_lcnt_dec(&args.br->br_nfiles); ++ } ++ goto out_sb; /* success */ ++ ++out_parent: ++ di_write_unlock(parent); ++ di_write_unlock(dentry); ++out_sb: ++ si_read_unlock(sb); ++out: ++ AuTraceErr(err); ++ AuDbgFile(file); ++ return err; ++} ++ ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_wr_dir_cpup(struct dentry *dentry, struct dentry *parent, ++ const unsigned char add_entry, aufs_bindex_t bcpup, ++ aufs_bindex_t btop) ++{ ++ int err; ++ struct dentry *h_parent; ++ struct inode *h_dir; ++ ++ if (add_entry) ++ IMustLock(d_inode(parent)); ++ else ++ di_write_lock_parent(parent); ++ ++ err = 0; ++ if (!au_h_dptr(parent, bcpup)) { ++ if (btop > bcpup) ++ err = au_cpup_dirs(dentry, bcpup); ++ else if (btop < bcpup) ++ err = au_cpdown_dirs(dentry, bcpup); ++ else ++ BUG(); ++ } ++ if (!err && add_entry && !au_ftest_wrdir(add_entry, TMPFILE)) { ++ h_parent = au_h_dptr(parent, bcpup); ++ h_dir = d_inode(h_parent); ++ inode_lock_shared_nested(h_dir, AuLsc_I_PARENT); ++ err = au_lkup_neg(dentry, bcpup, /*wh*/0); ++ /* todo: no unlock here */ ++ inode_unlock_shared(h_dir); ++ ++ AuDbg("bcpup %d\n", bcpup); ++ if (!err) { ++ if (d_really_is_negative(dentry)) ++ au_set_h_dptr(dentry, btop, NULL); ++ au_update_dbrange(dentry, /*do_put_zero*/0); ++ } ++ } ++ ++ if (!add_entry) ++ di_write_unlock(parent); ++ if (!err) ++ err = bcpup; /* success */ ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ++ * decide the branch and the parent dir where we will create a new entry. ++ * returns new bindex or an error. ++ * copyup the parent dir if needed. ++ */ ++int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry, ++ struct au_wr_dir_args *args) ++{ ++ int err; ++ unsigned int flags; ++ aufs_bindex_t bcpup, btop, src_btop; ++ const unsigned char add_entry ++ = au_ftest_wrdir(args->flags, ADD_ENTRY) ++ | au_ftest_wrdir(args->flags, TMPFILE); ++ struct super_block *sb; ++ struct dentry *parent; ++ struct au_sbinfo *sbinfo; ++ ++ sb = dentry->d_sb; ++ sbinfo = au_sbi(sb); ++ parent = dget_parent(dentry); ++ btop = au_dbtop(dentry); ++ bcpup = btop; ++ if (args->force_btgt < 0) { ++ if (src_dentry) { ++ src_btop = au_dbtop(src_dentry); ++ if (src_btop < btop) ++ bcpup = src_btop; ++ } else if (add_entry) { ++ flags = 0; ++ if (au_ftest_wrdir(args->flags, ISDIR)) ++ au_fset_wbr(flags, DIR); ++ err = AuWbrCreate(sbinfo, dentry, flags); ++ bcpup = err; ++ } ++ ++ if (bcpup < 0 || au_test_ro(sb, bcpup, d_inode(dentry))) { ++ if (add_entry) ++ err = AuWbrCopyup(sbinfo, dentry); ++ else { ++ if (!IS_ROOT(dentry)) { ++ di_read_lock_parent(parent, !AuLock_IR); ++ err = AuWbrCopyup(sbinfo, dentry); ++ di_read_unlock(parent, !AuLock_IR); ++ } else ++ err = AuWbrCopyup(sbinfo, dentry); ++ } ++ bcpup = err; ++ if (unlikely(err < 0)) ++ goto out; ++ } ++ } else { ++ bcpup = args->force_btgt; ++ AuDebugOn(au_test_ro(sb, bcpup, d_inode(dentry))); ++ } ++ ++ AuDbg("btop %d, bcpup %d\n", btop, bcpup); ++ err = bcpup; ++ if (bcpup == btop) ++ goto out; /* success */ ++ ++ /* copyup the new parent into the branch we process */ ++ err = au_wr_dir_cpup(dentry, parent, add_entry, bcpup, btop); ++ if (err >= 0) { ++ if (d_really_is_negative(dentry)) { ++ au_set_h_dptr(dentry, btop, NULL); ++ au_set_dbtop(dentry, bcpup); ++ au_set_dbbot(dentry, bcpup); ++ } ++ AuDebugOn(add_entry ++ && !au_ftest_wrdir(args->flags, TMPFILE) ++ && !au_h_dptr(dentry, bcpup)); ++ } ++ ++out: ++ dput(parent); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_pin_hdir_unlock(struct au_pin *p) ++{ ++ if (p->hdir) ++ au_hn_inode_unlock(p->hdir); ++} ++ ++int au_pin_hdir_lock(struct au_pin *p) ++{ ++ int err; ++ ++ err = 0; ++ if (!p->hdir) ++ goto out; ++ ++ /* even if an error happens later, keep this lock */ ++ au_hn_inode_lock_nested(p->hdir, p->lsc_hi); ++ ++ err = -EBUSY; ++ if (unlikely(p->hdir->hi_inode != d_inode(p->h_parent))) ++ goto out; ++ ++ err = 0; ++ if (p->h_dentry) ++ err = au_h_verify(p->h_dentry, p->udba, p->hdir->hi_inode, ++ p->h_parent, p->br); ++ ++out: ++ return err; ++} ++ ++int au_pin_hdir_relock(struct au_pin *p) ++{ ++ int err, i; ++ struct inode *h_i; ++ struct dentry *h_d[] = { ++ p->h_dentry, ++ p->h_parent ++ }; ++ ++ err = au_pin_hdir_lock(p); ++ if (unlikely(err)) ++ goto out; ++ ++ for (i = 0; !err && i < sizeof(h_d)/sizeof(*h_d); i++) { ++ if (!h_d[i]) ++ continue; ++ if (d_is_positive(h_d[i])) { ++ h_i = d_inode(h_d[i]); ++ err = !h_i->i_nlink; ++ } ++ } ++ ++out: ++ return err; ++} ++ ++static void au_pin_hdir_set_owner(struct au_pin *p, struct task_struct *task) ++{ ++ atomic_long_set(&p->hdir->hi_inode->i_rwsem.owner, (long)task); ++} ++ ++void au_pin_hdir_acquire_nest(struct au_pin *p) ++{ ++ if (p->hdir) { ++ rwsem_acquire_nest(&p->hdir->hi_inode->i_rwsem.dep_map, ++ p->lsc_hi, 0, NULL, _RET_IP_); ++ au_pin_hdir_set_owner(p, current); ++ } ++} ++ ++void au_pin_hdir_release(struct au_pin *p) ++{ ++ if (p->hdir) { ++ au_pin_hdir_set_owner(p, p->task); ++ rwsem_release(&p->hdir->hi_inode->i_rwsem.dep_map, _RET_IP_); ++ } ++} ++ ++struct dentry *au_pinned_h_parent(struct au_pin *pin) ++{ ++ if (pin && pin->parent) ++ return au_h_dptr(pin->parent, pin->bindex); ++ return NULL; ++} ++ ++void au_unpin(struct au_pin *p) ++{ ++ if (p->hdir) ++ au_pin_hdir_unlock(p); ++ if (p->h_mnt && au_ftest_pin(p->flags, MNT_WRITE)) ++ vfsub_mnt_drop_write(p->h_mnt); ++ if (!p->hdir) ++ return; ++ ++ if (!au_ftest_pin(p->flags, DI_LOCKED)) ++ di_read_unlock(p->parent, AuLock_IR); ++ iput(p->hdir->hi_inode); ++ dput(p->parent); ++ p->parent = NULL; ++ p->hdir = NULL; ++ p->h_mnt = NULL; ++ /* do not clear p->task */ ++} ++ ++int au_do_pin(struct au_pin *p) ++{ ++ int err; ++ struct super_block *sb; ++ struct inode *h_dir; ++ ++ err = 0; ++ sb = p->dentry->d_sb; ++ p->br = au_sbr(sb, p->bindex); ++ if (IS_ROOT(p->dentry)) { ++ if (au_ftest_pin(p->flags, MNT_WRITE)) { ++ p->h_mnt = au_br_mnt(p->br); ++ err = vfsub_mnt_want_write(p->h_mnt); ++ if (unlikely(err)) { ++ au_fclr_pin(p->flags, MNT_WRITE); ++ goto out_err; ++ } ++ } ++ goto out; ++ } ++ ++ p->h_dentry = NULL; ++ if (p->bindex <= au_dbbot(p->dentry)) ++ p->h_dentry = au_h_dptr(p->dentry, p->bindex); ++ ++ p->parent = dget_parent(p->dentry); ++ if (!au_ftest_pin(p->flags, DI_LOCKED)) ++ di_read_lock(p->parent, AuLock_IR, p->lsc_di); ++ ++ h_dir = NULL; ++ p->h_parent = au_h_dptr(p->parent, p->bindex); ++ p->hdir = au_hi(d_inode(p->parent), p->bindex); ++ if (p->hdir) ++ h_dir = p->hdir->hi_inode; ++ ++ /* ++ * udba case, or ++ * if DI_LOCKED is not set, then p->parent may be different ++ * and h_parent can be NULL. ++ */ ++ if (unlikely(!p->hdir || !h_dir || !p->h_parent)) { ++ err = -EBUSY; ++ if (!au_ftest_pin(p->flags, DI_LOCKED)) ++ di_read_unlock(p->parent, AuLock_IR); ++ dput(p->parent); ++ p->parent = NULL; ++ goto out_err; ++ } ++ ++ if (au_ftest_pin(p->flags, MNT_WRITE)) { ++ p->h_mnt = au_br_mnt(p->br); ++ err = vfsub_mnt_want_write(p->h_mnt); ++ if (unlikely(err)) { ++ au_fclr_pin(p->flags, MNT_WRITE); ++ if (!au_ftest_pin(p->flags, DI_LOCKED)) ++ di_read_unlock(p->parent, AuLock_IR); ++ dput(p->parent); ++ p->parent = NULL; ++ goto out_err; ++ } ++ } ++ ++ au_igrab(h_dir); ++ err = au_pin_hdir_lock(p); ++ if (!err) ++ goto out; /* success */ ++ ++ au_unpin(p); ++ ++out_err: ++ pr_err("err %d\n", err); ++ err = au_busy_or_stale(); ++out: ++ return err; ++} ++ ++void au_pin_init(struct au_pin *p, struct dentry *dentry, ++ aufs_bindex_t bindex, int lsc_di, int lsc_hi, ++ unsigned int udba, unsigned char flags) ++{ ++ p->dentry = dentry; ++ p->udba = udba; ++ p->lsc_di = lsc_di; ++ p->lsc_hi = lsc_hi; ++ p->flags = flags; ++ p->bindex = bindex; ++ ++ p->parent = NULL; ++ p->hdir = NULL; ++ p->h_mnt = NULL; ++ ++ p->h_dentry = NULL; ++ p->h_parent = NULL; ++ p->br = NULL; ++ p->task = current; ++} ++ ++int au_pin(struct au_pin *pin, struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int udba, unsigned char flags) ++{ ++ au_pin_init(pin, dentry, bindex, AuLsc_DI_PARENT, AuLsc_I_PARENT2, ++ udba, flags); ++ return au_do_pin(pin); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * ->setattr() and ->getattr() are called in various cases. ++ * chmod, stat: dentry is revalidated. ++ * fchmod, fstat: file and dentry are not revalidated, additionally they may be ++ * unhashed. ++ * for ->setattr(), ia->ia_file is passed from ftruncate only. ++ */ ++/* todo: consolidate with do_refresh() and simple_reval_dpath() */ ++int au_reval_for_attr(struct dentry *dentry, unsigned int sigen) ++{ ++ int err; ++ struct dentry *parent; ++ ++ err = 0; ++ if (au_digen_test(dentry, sigen)) { ++ parent = dget_parent(dentry); ++ di_read_lock_parent(parent, AuLock_IR); ++ err = au_refresh_dentry(dentry, parent); ++ di_read_unlock(parent, AuLock_IR); ++ dput(parent); ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_pin_and_icpup(struct dentry *dentry, struct iattr *ia, ++ struct au_icpup_args *a) ++{ ++ int err; ++ loff_t sz; ++ aufs_bindex_t btop, ibtop; ++ struct dentry *hi_wh, *parent; ++ struct inode *inode; ++ struct au_wr_dir_args wr_dir_args = { ++ .force_btgt = -1, ++ .flags = 0 ++ }; ++ ++ if (d_is_dir(dentry)) ++ au_fset_wrdir(wr_dir_args.flags, ISDIR); ++ /* plink or hi_wh() case */ ++ btop = au_dbtop(dentry); ++ inode = d_inode(dentry); ++ ibtop = au_ibtop(inode); ++ if (btop != ibtop && !au_test_ro(inode->i_sb, ibtop, inode)) ++ wr_dir_args.force_btgt = ibtop; ++ err = au_wr_dir(dentry, /*src_dentry*/NULL, &wr_dir_args); ++ if (unlikely(err < 0)) ++ goto out; ++ a->btgt = err; ++ if (err != btop) ++ au_fset_icpup(a->flags, DID_CPUP); ++ ++ err = 0; ++ a->pin_flags = AuPin_MNT_WRITE; ++ parent = NULL; ++ if (!IS_ROOT(dentry)) { ++ au_fset_pin(a->pin_flags, DI_LOCKED); ++ parent = dget_parent(dentry); ++ di_write_lock_parent(parent); ++ } ++ ++ err = au_pin(&a->pin, dentry, a->btgt, a->udba, a->pin_flags); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ sz = -1; ++ a->h_path.dentry = au_h_dptr(dentry, btop); ++ a->h_inode = d_inode(a->h_path.dentry); ++ if (ia && (ia->ia_valid & ATTR_SIZE)) { ++ inode_lock_shared_nested(a->h_inode, AuLsc_I_CHILD); ++ if (ia->ia_size < i_size_read(a->h_inode)) ++ sz = ia->ia_size; ++ inode_unlock_shared(a->h_inode); ++ } ++ ++ hi_wh = NULL; ++ if (au_ftest_icpup(a->flags, DID_CPUP) && d_unlinked(dentry)) { ++ hi_wh = au_hi_wh(inode, a->btgt); ++ if (!hi_wh) { ++ struct au_cp_generic cpg = { ++ .dentry = dentry, ++ .bdst = a->btgt, ++ .bsrc = -1, ++ .len = sz, ++ .pin = &a->pin ++ }; ++ err = au_sio_cpup_wh(&cpg, /*file*/NULL); ++ if (unlikely(err)) ++ goto out_unlock; ++ hi_wh = au_hi_wh(inode, a->btgt); ++ /* todo: revalidate hi_wh? */ ++ } ++ } ++ ++ if (parent) { ++ au_pin_set_parent_lflag(&a->pin, /*lflag*/0); ++ di_downgrade_lock(parent, AuLock_IR); ++ dput(parent); ++ parent = NULL; ++ } ++ if (!au_ftest_icpup(a->flags, DID_CPUP)) ++ goto out; /* success */ ++ ++ if (!d_unhashed(dentry)) { ++ struct au_cp_generic cpg = { ++ .dentry = dentry, ++ .bdst = a->btgt, ++ .bsrc = btop, ++ .len = sz, ++ .pin = &a->pin, ++ .flags = AuCpup_DTIME | AuCpup_HOPEN ++ }; ++ err = au_sio_cpup_simple(&cpg); ++ if (!err) ++ a->h_path.dentry = au_h_dptr(dentry, a->btgt); ++ } else if (!hi_wh) ++ a->h_path.dentry = au_h_dptr(dentry, a->btgt); ++ else ++ a->h_path.dentry = hi_wh; /* do not dget here */ ++ ++out_unlock: ++ a->h_inode = d_inode(a->h_path.dentry); ++ if (!err) ++ goto out; /* success */ ++ au_unpin(&a->pin); ++out_parent: ++ if (parent) { ++ di_write_unlock(parent); ++ dput(parent); ++ } ++out: ++ if (!err) ++ inode_lock_nested(a->h_inode, AuLsc_I_CHILD); ++ return err; ++} ++ ++static int aufs_setattr(struct dentry *dentry, struct iattr *ia) ++{ ++ int err; ++ struct inode *inode, *delegated; ++ struct super_block *sb; ++ struct file *file; ++ struct au_icpup_args *a; ++ ++ inode = d_inode(dentry); ++ IMustLock(inode); ++ ++ err = setattr_prepare(dentry, ia); ++ if (unlikely(err)) ++ goto out; ++ ++ err = -ENOMEM; ++ a = kzalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ if (ia->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) ++ ia->ia_valid &= ~ATTR_MODE; ++ ++ file = NULL; ++ sb = dentry->d_sb; ++ err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (unlikely(err)) ++ goto out_kfree; ++ ++ if (ia->ia_valid & ATTR_FILE) { ++ /* currently ftruncate(2) only */ ++ AuDebugOn(!d_is_reg(dentry)); ++ file = ia->ia_file; ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/1, ++ /*fi_lsc*/0); ++ if (unlikely(err)) ++ goto out_si; ++ ia->ia_file = au_hf_top(file); ++ a->udba = AuOpt_UDBA_NONE; ++ } else { ++ /* fchmod() doesn't pass ia_file */ ++ a->udba = au_opt_udba(sb); ++ di_write_lock_child(dentry); ++ /* no d_unlinked(), to set UDBA_NONE for root */ ++ if (d_unhashed(dentry)) ++ a->udba = AuOpt_UDBA_NONE; ++ if (a->udba != AuOpt_UDBA_NONE) { ++ AuDebugOn(IS_ROOT(dentry)); ++ err = au_reval_for_attr(dentry, au_sigen(sb)); ++ if (unlikely(err)) ++ goto out_dentry; ++ } ++ } ++ ++ err = au_pin_and_icpup(dentry, ia, a); ++ if (unlikely(err < 0)) ++ goto out_dentry; ++ if (au_ftest_icpup(a->flags, DID_CPUP)) { ++ ia->ia_file = NULL; ++ ia->ia_valid &= ~ATTR_FILE; ++ } ++ ++ a->h_path.mnt = au_sbr_mnt(sb, a->btgt); ++ if ((ia->ia_valid & (ATTR_MODE | ATTR_CTIME)) ++ == (ATTR_MODE | ATTR_CTIME)) { ++ err = security_path_chmod(&a->h_path, ia->ia_mode); ++ if (unlikely(err)) ++ goto out_unlock; ++ } else if ((ia->ia_valid & (ATTR_UID | ATTR_GID)) ++ && (ia->ia_valid & ATTR_CTIME)) { ++ err = security_path_chown(&a->h_path, ia->ia_uid, ia->ia_gid); ++ if (unlikely(err)) ++ goto out_unlock; ++ } ++ ++ if (ia->ia_valid & ATTR_SIZE) { ++ struct file *f; ++ ++ if (ia->ia_size < i_size_read(inode)) ++ /* unmap only */ ++ truncate_setsize(inode, ia->ia_size); ++ ++ f = NULL; ++ if (ia->ia_valid & ATTR_FILE) ++ f = ia->ia_file; ++ inode_unlock(a->h_inode); ++ err = vfsub_trunc(&a->h_path, ia->ia_size, ia->ia_valid, f); ++ inode_lock_nested(a->h_inode, AuLsc_I_CHILD); ++ } else { ++ delegated = NULL; ++ while (1) { ++ err = vfsub_notify_change(&a->h_path, ia, &delegated); ++ if (delegated) { ++ err = break_deleg_wait(&delegated); ++ if (!err) ++ continue; ++ } ++ break; ++ } ++ } ++ /* ++ * regardless aufs 'acl' option setting. ++ * why don't all acl-aware fs call this func from their ->setattr()? ++ */ ++ if (!err && (ia->ia_valid & ATTR_MODE)) ++ err = vfsub_acl_chmod(a->h_inode, ia->ia_mode); ++ if (!err) ++ au_cpup_attr_changeable(inode); ++ ++out_unlock: ++ inode_unlock(a->h_inode); ++ au_unpin(&a->pin); ++ if (unlikely(err)) ++ au_update_dbtop(dentry); ++out_dentry: ++ di_write_unlock(dentry); ++ if (file) { ++ fi_write_unlock(file); ++ ia->ia_file = file; ++ ia->ia_valid |= ATTR_FILE; ++ } ++out_si: ++ si_read_unlock(sb); ++out_kfree: ++ au_kfree_rcu(a); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++#if IS_ENABLED(CONFIG_AUFS_XATTR) || IS_ENABLED(CONFIG_FS_POSIX_ACL) ++static int au_h_path_to_set_attr(struct dentry *dentry, ++ struct au_icpup_args *a, struct path *h_path) ++{ ++ int err; ++ struct super_block *sb; ++ ++ sb = dentry->d_sb; ++ a->udba = au_opt_udba(sb); ++ /* no d_unlinked(), to set UDBA_NONE for root */ ++ if (d_unhashed(dentry)) ++ a->udba = AuOpt_UDBA_NONE; ++ if (a->udba != AuOpt_UDBA_NONE) { ++ AuDebugOn(IS_ROOT(dentry)); ++ err = au_reval_for_attr(dentry, au_sigen(sb)); ++ if (unlikely(err)) ++ goto out; ++ } ++ err = au_pin_and_icpup(dentry, /*ia*/NULL, a); ++ if (unlikely(err < 0)) ++ goto out; ++ ++ h_path->dentry = a->h_path.dentry; ++ h_path->mnt = au_sbr_mnt(sb, a->btgt); ++ ++out: ++ return err; ++} ++ ++ssize_t au_sxattr(struct dentry *dentry, struct inode *inode, ++ struct au_sxattr *arg) ++{ ++ int err; ++ struct path h_path; ++ struct super_block *sb; ++ struct au_icpup_args *a; ++ struct inode *h_inode; ++ ++ IMustLock(inode); ++ ++ err = -ENOMEM; ++ a = kzalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (unlikely(err)) ++ goto out_kfree; ++ ++ h_path.dentry = NULL; /* silence gcc */ ++ di_write_lock_child(dentry); ++ err = au_h_path_to_set_attr(dentry, a, &h_path); ++ if (unlikely(err)) ++ goto out_di; ++ ++ inode_unlock(a->h_inode); ++ switch (arg->type) { ++ case AU_XATTR_SET: ++ AuDebugOn(d_is_negative(h_path.dentry)); ++ err = vfsub_setxattr(h_path.dentry, ++ arg->u.set.name, arg->u.set.value, ++ arg->u.set.size, arg->u.set.flags); ++ break; ++ case AU_ACL_SET: ++ err = -EOPNOTSUPP; ++ h_inode = d_inode(h_path.dentry); ++ if (h_inode->i_op->set_acl) ++ /* this will call posix_acl_update_mode */ ++ err = h_inode->i_op->set_acl(h_inode, ++ arg->u.acl_set.acl, ++ arg->u.acl_set.type); ++ break; ++ } ++ if (!err) ++ au_cpup_attr_timesizes(inode); ++ ++ au_unpin(&a->pin); ++ if (unlikely(err)) ++ au_update_dbtop(dentry); ++ ++out_di: ++ di_write_unlock(dentry); ++ si_read_unlock(sb); ++out_kfree: ++ au_kfree_rcu(a); ++out: ++ AuTraceErr(err); ++ return err; ++} ++#endif ++ ++static void au_refresh_iattr(struct inode *inode, struct kstat *st, ++ unsigned int nlink) ++{ ++ unsigned int n; ++ ++ inode->i_mode = st->mode; ++ /* don't i_[ug]id_write() here */ ++ inode->i_uid = st->uid; ++ inode->i_gid = st->gid; ++ inode->i_atime = st->atime; ++ inode->i_mtime = st->mtime; ++ inode->i_ctime = st->ctime; ++ ++ au_cpup_attr_nlink(inode, /*force*/0); ++ if (S_ISDIR(inode->i_mode)) { ++ n = inode->i_nlink; ++ n -= nlink; ++ n += st->nlink; ++ smp_mb(); /* for i_nlink */ ++ /* 0 can happen */ ++ set_nlink(inode, n); ++ } ++ ++ spin_lock(&inode->i_lock); ++ inode->i_blocks = st->blocks; ++ i_size_write(inode, st->size); ++ spin_unlock(&inode->i_lock); ++} ++ ++/* ++ * common routine for aufs_getattr() and au_getxattr(). ++ * returns zero or negative (an error). ++ * @dentry will be read-locked in success. ++ */ ++int au_h_path_getattr(struct dentry *dentry, struct inode *inode, int force, ++ struct path *h_path, int locked) ++{ ++ int err; ++ unsigned int mnt_flags, sigen; ++ unsigned char udba_none; ++ aufs_bindex_t bindex; ++ struct super_block *sb, *h_sb; ++ ++ h_path->mnt = NULL; ++ h_path->dentry = NULL; ++ ++ err = 0; ++ sb = dentry->d_sb; ++ mnt_flags = au_mntflags(sb); ++ udba_none = !!au_opt_test(mnt_flags, UDBA_NONE); ++ ++ if (unlikely(locked)) ++ goto body; /* skip locking dinfo */ ++ ++ /* support fstat(2) */ ++ if (!d_unlinked(dentry) && !udba_none) { ++ sigen = au_sigen(sb); ++ err = au_digen_test(dentry, sigen); ++ if (!err) { ++ di_read_lock_child(dentry, AuLock_IR); ++ err = au_dbrange_test(dentry); ++ if (unlikely(err)) { ++ di_read_unlock(dentry, AuLock_IR); ++ goto out; ++ } ++ } else { ++ AuDebugOn(IS_ROOT(dentry)); ++ di_write_lock_child(dentry); ++ err = au_dbrange_test(dentry); ++ if (!err) ++ err = au_reval_for_attr(dentry, sigen); ++ if (!err) ++ di_downgrade_lock(dentry, AuLock_IR); ++ else { ++ di_write_unlock(dentry); ++ goto out; ++ } ++ } ++ } else ++ di_read_lock_child(dentry, AuLock_IR); ++ ++body: ++ if (!inode) { ++ inode = d_inode(dentry); ++ if (unlikely(!inode)) ++ goto out; ++ } ++ bindex = au_ibtop(inode); ++ h_path->mnt = au_sbr_mnt(sb, bindex); ++ h_sb = h_path->mnt->mnt_sb; ++ if (!force ++ && !au_test_fs_bad_iattr(h_sb) ++ && udba_none) ++ goto out; /* success */ ++ ++ if (au_dbtop(dentry) == bindex) ++ h_path->dentry = au_h_dptr(dentry, bindex); ++ else if (au_opt_test(mnt_flags, PLINK) && au_plink_test(inode)) { ++ h_path->dentry = au_plink_lkup(inode, bindex); ++ if (IS_ERR(h_path->dentry)) ++ /* pretending success */ ++ h_path->dentry = NULL; ++ else ++ dput(h_path->dentry); ++ } ++ ++out: ++ return err; ++} ++ ++static int aufs_getattr(const struct path *path, struct kstat *st, ++ u32 request, unsigned int query) ++{ ++ int err; ++ unsigned char positive; ++ struct path h_path; ++ struct dentry *dentry; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ dentry = path->dentry; ++ inode = d_inode(dentry); ++ sb = dentry->d_sb; ++ err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (unlikely(err)) ++ goto out; ++ err = au_h_path_getattr(dentry, /*inode*/NULL, /*force*/0, &h_path, ++ /*locked*/0); ++ if (unlikely(err)) ++ goto out_si; ++ if (unlikely(!h_path.dentry)) ++ /* illegally overlapped or something */ ++ goto out_fill; /* pretending success */ ++ ++ positive = d_is_positive(h_path.dentry); ++ if (positive) ++ /* no vfsub version */ ++ err = vfs_getattr(&h_path, st, request, query); ++ if (!err) { ++ if (positive) ++ au_refresh_iattr(inode, st, ++ d_inode(h_path.dentry)->i_nlink); ++ goto out_fill; /* success */ ++ } ++ AuTraceErr(err); ++ goto out_di; ++ ++out_fill: ++ generic_fillattr(inode, st); ++out_di: ++ di_read_unlock(dentry, AuLock_IR); ++out_si: ++ si_read_unlock(sb); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static const char *aufs_get_link(struct dentry *dentry, struct inode *inode, ++ struct delayed_call *done) ++{ ++ const char *ret; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ int err; ++ aufs_bindex_t bindex; ++ ++ ret = NULL; /* suppress a warning */ ++ err = -ECHILD; ++ if (!dentry) ++ goto out; ++ ++ err = aufs_read_lock(dentry, AuLock_IR | AuLock_GEN); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_d_hashed_positive(dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ err = -EINVAL; ++ inode = d_inode(dentry); ++ bindex = au_ibtop(inode); ++ h_inode = au_h_iptr(inode, bindex); ++ if (unlikely(!h_inode->i_op->get_link)) ++ goto out_unlock; ++ ++ err = -EBUSY; ++ h_dentry = NULL; ++ if (au_dbtop(dentry) <= bindex) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry) ++ dget(h_dentry); ++ } ++ if (!h_dentry) { ++ h_dentry = d_find_any_alias(h_inode); ++ if (IS_ERR(h_dentry)) { ++ err = PTR_ERR(h_dentry); ++ goto out_unlock; ++ } ++ } ++ if (unlikely(!h_dentry)) ++ goto out_unlock; ++ ++ err = 0; ++ AuDbg("%ps\n", h_inode->i_op->get_link); ++ AuDbgDentry(h_dentry); ++ ret = vfs_get_link(h_dentry, done); ++ dput(h_dentry); ++ if (IS_ERR(ret)) ++ err = PTR_ERR(ret); ++ ++out_unlock: ++ aufs_read_unlock(dentry, AuLock_IR); ++out: ++ if (unlikely(err)) ++ ret = ERR_PTR(err); ++ AuTraceErrPtr(ret); ++ return ret; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_is_special(struct inode *inode) ++{ ++ return (inode->i_mode & (S_IFBLK | S_IFCHR | S_IFIFO | S_IFSOCK)); ++} ++ ++static int aufs_update_time(struct inode *inode, struct timespec64 *ts, ++ int flags) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct super_block *sb; ++ struct inode *h_inode; ++ struct vfsmount *h_mnt; ++ ++ sb = inode->i_sb; ++ WARN_ONCE((flags & S_ATIME) && !IS_NOATIME(inode), ++ "unexpected s_flags 0x%lx", sb->s_flags); ++ ++ /* mmap_sem might be acquired already, cf. aufs_mmap() */ ++ lockdep_off(); ++ si_read_lock(sb, AuLock_FLUSH); ++ ii_write_lock_child(inode); ++ ++ err = 0; ++ bindex = au_ibtop(inode); ++ h_inode = au_h_iptr(inode, bindex); ++ if (!au_test_ro(sb, bindex, inode)) { ++ h_mnt = au_sbr_mnt(sb, bindex); ++ err = vfsub_mnt_want_write(h_mnt); ++ if (!err) { ++ err = vfsub_update_time(h_inode, ts, flags); ++ vfsub_mnt_drop_write(h_mnt); ++ } ++ } else if (au_is_special(h_inode)) { ++ /* ++ * Never copy-up here. ++ * These special files may already be opened and used for ++ * communicating. If we copied it up, then the communication ++ * would be corrupted. ++ */ ++ AuWarn1("timestamps for i%lu are ignored " ++ "since it is on readonly branch (hi%lu).\n", ++ inode->i_ino, h_inode->i_ino); ++ } else if (flags & ~S_ATIME) { ++ err = -EIO; ++ AuIOErr1("unexpected flags 0x%x\n", flags); ++ AuDebugOn(1); ++ } ++ ++ if (!err) ++ au_cpup_attr_timesizes(inode); ++ ii_write_unlock(inode); ++ si_read_unlock(sb); ++ lockdep_on(); ++ ++ if (!err && (flags & S_VERSION)) ++ inode_inc_iversion(inode); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* no getattr version will be set by module.c:aufs_init() */ ++struct inode_operations aufs_iop_nogetattr[AuIop_Last], ++ aufs_iop[] = { ++ [AuIop_SYMLINK] = { ++ .permission = aufs_permission, ++#ifdef CONFIG_FS_POSIX_ACL ++ .get_acl = aufs_get_acl, ++ .set_acl = aufs_set_acl, /* unsupport for symlink? */ ++#endif ++ ++ .setattr = aufs_setattr, ++ .getattr = aufs_getattr, ++ ++#ifdef CONFIG_AUFS_XATTR ++ .listxattr = aufs_listxattr, ++#endif ++ ++ .get_link = aufs_get_link, ++ ++ /* .update_time = aufs_update_time */ ++ }, ++ [AuIop_DIR] = { ++ .create = aufs_create, ++ .lookup = aufs_lookup, ++ .link = aufs_link, ++ .unlink = aufs_unlink, ++ .symlink = aufs_symlink, ++ .mkdir = aufs_mkdir, ++ .rmdir = aufs_rmdir, ++ .mknod = aufs_mknod, ++ .rename = aufs_rename, ++ ++ .permission = aufs_permission, ++#ifdef CONFIG_FS_POSIX_ACL ++ .get_acl = aufs_get_acl, ++ .set_acl = aufs_set_acl, ++#endif ++ ++ .setattr = aufs_setattr, ++ .getattr = aufs_getattr, ++ ++#ifdef CONFIG_AUFS_XATTR ++ .listxattr = aufs_listxattr, ++#endif ++ ++ .update_time = aufs_update_time, ++ .atomic_open = aufs_atomic_open, ++ .tmpfile = aufs_tmpfile ++ }, ++ [AuIop_OTHER] = { ++ .permission = aufs_permission, ++#ifdef CONFIG_FS_POSIX_ACL ++ .get_acl = aufs_get_acl, ++ .set_acl = aufs_set_acl, ++#endif ++ ++ .setattr = aufs_setattr, ++ .getattr = aufs_getattr, ++ ++#ifdef CONFIG_AUFS_XATTR ++ .listxattr = aufs_listxattr, ++#endif ++ ++ .update_time = aufs_update_time ++ } ++}; +diff --git a/fs/aufs/i_op_add.c b/fs/aufs/i_op_add.c +new file mode 100644 +index 000000000000..853c99e200da +--- /dev/null ++++ b/fs/aufs/i_op_add.c +@@ -0,0 +1,923 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * inode operations (add entry) ++ */ ++ ++#include ++#include "aufs.h" ++ ++/* ++ * final procedure of adding a new entry, except link(2). ++ * remove whiteout, instantiate, copyup the parent dir's times and size ++ * and update version. ++ * if it failed, re-create the removed whiteout. ++ */ ++static int epilog(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct dentry *dentry) ++{ ++ int err, rerr; ++ aufs_bindex_t bwh; ++ struct path h_path; ++ struct super_block *sb; ++ struct inode *inode, *h_dir; ++ struct dentry *wh; ++ ++ bwh = -1; ++ sb = dir->i_sb; ++ if (wh_dentry) { ++ h_dir = d_inode(wh_dentry->d_parent); /* dir inode is locked */ ++ IMustLock(h_dir); ++ AuDebugOn(au_h_iptr(dir, bindex) != h_dir); ++ bwh = au_dbwh(dentry); ++ h_path.dentry = wh_dentry; ++ h_path.mnt = au_sbr_mnt(sb, bindex); ++ err = au_wh_unlink_dentry(au_h_iptr(dir, bindex), &h_path, ++ dentry); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ inode = au_new_inode(dentry, /*must_new*/1); ++ if (!IS_ERR(inode)) { ++ d_instantiate(dentry, inode); ++ dir = d_inode(dentry->d_parent); /* dir inode is locked */ ++ IMustLock(dir); ++ au_dir_ts(dir, bindex); ++ inode_inc_iversion(dir); ++ au_fhsm_wrote(sb, bindex, /*force*/0); ++ return 0; /* success */ ++ } ++ ++ err = PTR_ERR(inode); ++ if (!wh_dentry) ++ goto out; ++ ++ /* revert */ ++ /* dir inode is locked */ ++ wh = au_wh_create(dentry, bwh, wh_dentry->d_parent); ++ rerr = PTR_ERR(wh); ++ if (IS_ERR(wh)) { ++ AuIOErr("%pd reverting whiteout failed(%d, %d)\n", ++ dentry, err, rerr); ++ err = -EIO; ++ } else ++ dput(wh); ++ ++out: ++ return err; ++} ++ ++static int au_d_may_add(struct dentry *dentry) ++{ ++ int err; ++ ++ err = 0; ++ if (unlikely(d_unhashed(dentry))) ++ err = -ENOENT; ++ if (unlikely(d_really_is_positive(dentry))) ++ err = -EEXIST; ++ return err; ++} ++ ++/* ++ * simple tests for the adding inode operations. ++ * following the checks in vfs, plus the parent-child relationship. ++ */ ++int au_may_add(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir) ++{ ++ int err; ++ umode_t h_mode; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ ++ err = -ENAMETOOLONG; ++ if (unlikely(dentry->d_name.len > AUFS_MAX_NAMELEN)) ++ goto out; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (d_really_is_negative(dentry)) { ++ err = -EEXIST; ++ if (unlikely(d_is_positive(h_dentry))) ++ goto out; ++ } else { ++ /* rename(2) case */ ++ err = -EIO; ++ if (unlikely(d_is_negative(h_dentry))) ++ goto out; ++ h_inode = d_inode(h_dentry); ++ if (unlikely(!h_inode->i_nlink)) ++ goto out; ++ ++ h_mode = h_inode->i_mode; ++ if (!isdir) { ++ err = -EISDIR; ++ if (unlikely(S_ISDIR(h_mode))) ++ goto out; ++ } else if (unlikely(!S_ISDIR(h_mode))) { ++ err = -ENOTDIR; ++ goto out; ++ } ++ } ++ ++ err = 0; ++ /* expected parent dir is locked */ ++ if (unlikely(h_parent != h_dentry->d_parent)) ++ err = -EIO; ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ++ * initial procedure of adding a new entry. ++ * prepare writable branch and the parent dir, lock it, ++ * and lookup whiteout for the new entry. ++ */ ++static struct dentry* ++lock_hdir_lkup_wh(struct dentry *dentry, struct au_dtime *dt, ++ struct dentry *src_dentry, struct au_pin *pin, ++ struct au_wr_dir_args *wr_dir_args) ++{ ++ struct dentry *wh_dentry, *h_parent; ++ struct super_block *sb; ++ struct au_branch *br; ++ int err; ++ unsigned int udba; ++ aufs_bindex_t bcpup; ++ ++ AuDbg("%pd\n", dentry); ++ ++ err = au_wr_dir(dentry, src_dentry, wr_dir_args); ++ bcpup = err; ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err < 0)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ udba = au_opt_udba(sb); ++ err = au_pin(pin, dentry, bcpup, udba, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ h_parent = au_pinned_h_parent(pin); ++ if (udba != AuOpt_UDBA_NONE ++ && au_dbtop(dentry) == bcpup) ++ err = au_may_add(dentry, bcpup, h_parent, ++ au_ftest_wrdir(wr_dir_args->flags, ISDIR)); ++ else if (unlikely(dentry->d_name.len > AUFS_MAX_NAMELEN)) ++ err = -ENAMETOOLONG; ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_unpin; ++ ++ br = au_sbr(sb, bcpup); ++ if (dt) { ++ struct path tmp = { ++ .dentry = h_parent, ++ .mnt = au_br_mnt(br) ++ }; ++ au_dtime_store(dt, au_pinned_parent(pin), &tmp); ++ } ++ ++ wh_dentry = NULL; ++ if (bcpup != au_dbwh(dentry)) ++ goto out; /* success */ ++ ++ /* ++ * ENAMETOOLONG here means that if we allowed create such name, then it ++ * would not be able to removed in the future. So we don't allow such ++ * name here and we don't handle ENAMETOOLONG differently here. ++ */ ++ wh_dentry = au_wh_lkup(h_parent, &dentry->d_name, br); ++ ++out_unpin: ++ if (IS_ERR(wh_dentry)) ++ au_unpin(pin); ++out: ++ return wh_dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++enum { Mknod, Symlink, Creat }; ++struct simple_arg { ++ int type; ++ union { ++ struct { ++ umode_t mode; ++ bool want_excl; ++ bool try_aopen; ++ struct vfsub_aopen_args *aopen; ++ } c; ++ struct { ++ const char *symname; ++ } s; ++ struct { ++ umode_t mode; ++ dev_t dev; ++ } m; ++ } u; ++}; ++ ++static int add_simple(struct inode *dir, struct dentry *dentry, ++ struct simple_arg *arg) ++{ ++ int err, rerr; ++ aufs_bindex_t btop; ++ unsigned char created; ++ const unsigned char try_aopen ++ = (arg->type == Creat && arg->u.c.try_aopen); ++ struct vfsub_aopen_args *aopen = arg->u.c.aopen; ++ struct dentry *wh_dentry, *parent; ++ struct inode *h_dir; ++ struct super_block *sb; ++ struct au_branch *br; ++ /* to reduce stack size */ ++ struct { ++ struct au_dtime dt; ++ struct au_pin pin; ++ struct path h_path; ++ struct au_wr_dir_args wr_dir_args; ++ } *a; ++ ++ AuDbg("%pd\n", dentry); ++ IMustLock(dir); ++ ++ err = -ENOMEM; ++ a = kmalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ a->wr_dir_args.force_btgt = -1; ++ a->wr_dir_args.flags = AuWrDir_ADD_ENTRY; ++ ++ parent = dentry->d_parent; /* dir inode is locked */ ++ if (!try_aopen) { ++ err = aufs_read_lock(dentry, AuLock_DW | AuLock_GEN); ++ if (unlikely(err)) ++ goto out_free; ++ } ++ err = au_d_may_add(dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ if (!try_aopen) ++ di_write_lock_parent(parent); ++ wh_dentry = lock_hdir_lkup_wh(dentry, &a->dt, /*src_dentry*/NULL, ++ &a->pin, &a->wr_dir_args); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_parent; ++ ++ btop = au_dbtop(dentry); ++ sb = dentry->d_sb; ++ br = au_sbr(sb, btop); ++ a->h_path.dentry = au_h_dptr(dentry, btop); ++ a->h_path.mnt = au_br_mnt(br); ++ h_dir = au_pinned_h_dir(&a->pin); ++ switch (arg->type) { ++ case Creat: ++ if (!try_aopen || !h_dir->i_op->atomic_open) { ++ err = vfsub_create(h_dir, &a->h_path, arg->u.c.mode, ++ arg->u.c.want_excl); ++ created = !err; ++ if (!err && try_aopen) ++ aopen->file->f_mode |= FMODE_CREATED; ++ } else { ++ aopen->br = br; ++ err = vfsub_atomic_open(h_dir, a->h_path.dentry, aopen); ++ AuDbg("err %d\n", err); ++ AuDbgFile(aopen->file); ++ created = err >= 0 ++ && !!(aopen->file->f_mode & FMODE_CREATED); ++ } ++ break; ++ case Symlink: ++ err = vfsub_symlink(h_dir, &a->h_path, arg->u.s.symname); ++ created = !err; ++ break; ++ case Mknod: ++ err = vfsub_mknod(h_dir, &a->h_path, arg->u.m.mode, ++ arg->u.m.dev); ++ created = !err; ++ break; ++ default: ++ BUG(); ++ } ++ if (unlikely(err < 0)) ++ goto out_unpin; ++ ++ err = epilog(dir, btop, wh_dentry, dentry); ++ if (!err) ++ goto out_unpin; /* success */ ++ ++ /* revert */ ++ if (created /* && d_is_positive(a->h_path.dentry) */) { ++ /* no delegation since it is just created */ ++ rerr = vfsub_unlink(h_dir, &a->h_path, /*delegated*/NULL, ++ /*force*/0); ++ if (rerr) { ++ AuIOErr("%pd revert failure(%d, %d)\n", ++ dentry, err, rerr); ++ err = -EIO; ++ } ++ au_dtime_revert(&a->dt); ++ } ++ if (try_aopen && h_dir->i_op->atomic_open ++ && (aopen->file->f_mode & FMODE_OPENED)) ++ /* aopen->file is still opened */ ++ au_lcnt_dec(&aopen->br->br_nfiles); ++ ++out_unpin: ++ au_unpin(&a->pin); ++ dput(wh_dentry); ++out_parent: ++ if (!try_aopen) ++ di_write_unlock(parent); ++out_unlock: ++ if (unlikely(err)) { ++ au_update_dbtop(dentry); ++ d_drop(dentry); ++ } ++ if (!try_aopen) ++ aufs_read_unlock(dentry, AuLock_DW); ++out_free: ++ au_kfree_rcu(a); ++out: ++ return err; ++} ++ ++int aufs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, ++ dev_t dev) ++{ ++ struct simple_arg arg = { ++ .type = Mknod, ++ .u.m = { ++ .mode = mode, ++ .dev = dev ++ } ++ }; ++ return add_simple(dir, dentry, &arg); ++} ++ ++int aufs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) ++{ ++ struct simple_arg arg = { ++ .type = Symlink, ++ .u.s.symname = symname ++ }; ++ return add_simple(dir, dentry, &arg); ++} ++ ++int aufs_create(struct inode *dir, struct dentry *dentry, umode_t mode, ++ bool want_excl) ++{ ++ struct simple_arg arg = { ++ .type = Creat, ++ .u.c = { ++ .mode = mode, ++ .want_excl = want_excl ++ } ++ }; ++ return add_simple(dir, dentry, &arg); ++} ++ ++int au_aopen_or_create(struct inode *dir, struct dentry *dentry, ++ struct vfsub_aopen_args *aopen_args) ++{ ++ struct simple_arg arg = { ++ .type = Creat, ++ .u.c = { ++ .mode = aopen_args->create_mode, ++ .want_excl = aopen_args->open_flag & O_EXCL, ++ .try_aopen = true, ++ .aopen = aopen_args ++ } ++ }; ++ return add_simple(dir, dentry, &arg); ++} ++ ++int aufs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct super_block *sb; ++ struct dentry *parent, *h_parent, *h_dentry; ++ struct inode *h_dir, *inode; ++ struct vfsmount *h_mnt; ++ struct au_wr_dir_args wr_dir_args = { ++ .force_btgt = -1, ++ .flags = AuWrDir_TMPFILE ++ }; ++ ++ /* copy-up may happen */ ++ inode_lock(dir); ++ ++ sb = dir->i_sb; ++ err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_di_init(dentry); ++ if (unlikely(err)) ++ goto out_si; ++ ++ err = -EBUSY; ++ parent = d_find_any_alias(dir); ++ AuDebugOn(!parent); ++ di_write_lock_parent(parent); ++ if (unlikely(d_inode(parent) != dir)) ++ goto out_parent; ++ ++ err = au_digen_test(parent, au_sigen(sb)); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ bindex = au_dbtop(parent); ++ au_set_dbtop(dentry, bindex); ++ au_set_dbbot(dentry, bindex); ++ err = au_wr_dir(dentry, /*src_dentry*/NULL, &wr_dir_args); ++ bindex = err; ++ if (unlikely(err < 0)) ++ goto out_parent; ++ ++ err = -EOPNOTSUPP; ++ h_dir = au_h_iptr(dir, bindex); ++ if (unlikely(!h_dir->i_op->tmpfile)) ++ goto out_parent; ++ ++ h_mnt = au_sbr_mnt(sb, bindex); ++ err = vfsub_mnt_want_write(h_mnt); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ h_parent = au_h_dptr(parent, bindex); ++ h_dentry = vfs_tmpfile(h_parent, mode, /*open_flag*/0); ++ if (IS_ERR(h_dentry)) { ++ err = PTR_ERR(h_dentry); ++ goto out_mnt; ++ } ++ ++ au_set_dbtop(dentry, bindex); ++ au_set_dbbot(dentry, bindex); ++ au_set_h_dptr(dentry, bindex, dget(h_dentry)); ++ inode = au_new_inode(dentry, /*must_new*/1); ++ if (IS_ERR(inode)) { ++ err = PTR_ERR(inode); ++ au_set_h_dptr(dentry, bindex, NULL); ++ au_set_dbtop(dentry, -1); ++ au_set_dbbot(dentry, -1); ++ } else { ++ if (!inode->i_nlink) ++ set_nlink(inode, 1); ++ d_tmpfile(dentry, inode); ++ au_di(dentry)->di_tmpfile = 1; ++ ++ /* update without i_mutex */ ++ if (au_ibtop(dir) == au_dbtop(dentry)) ++ au_cpup_attr_timesizes(dir); ++ } ++ dput(h_dentry); ++ ++out_mnt: ++ vfsub_mnt_drop_write(h_mnt); ++out_parent: ++ di_write_unlock(parent); ++ dput(parent); ++ di_write_unlock(dentry); ++ if (unlikely(err)) { ++ au_di_fin(dentry); ++ dentry->d_fsdata = NULL; ++ } ++out_si: ++ si_read_unlock(sb); ++out: ++ inode_unlock(dir); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_link_args { ++ aufs_bindex_t bdst, bsrc; ++ struct au_pin pin; ++ struct path h_path; ++ struct dentry *src_parent, *parent; ++}; ++ ++static int au_cpup_before_link(struct dentry *src_dentry, ++ struct au_link_args *a) ++{ ++ int err; ++ struct dentry *h_src_dentry; ++ struct au_cp_generic cpg = { ++ .dentry = src_dentry, ++ .bdst = a->bdst, ++ .bsrc = a->bsrc, ++ .len = -1, ++ .pin = &a->pin, ++ .flags = AuCpup_DTIME | AuCpup_HOPEN /* | AuCpup_KEEPLINO */ ++ }; ++ ++ di_read_lock_parent(a->src_parent, AuLock_IR); ++ err = au_test_and_cpup_dirs(src_dentry, a->bdst); ++ if (unlikely(err)) ++ goto out; ++ ++ h_src_dentry = au_h_dptr(src_dentry, a->bsrc); ++ err = au_pin(&a->pin, src_dentry, a->bdst, ++ au_opt_udba(src_dentry->d_sb), ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_sio_cpup_simple(&cpg); ++ au_unpin(&a->pin); ++ ++out: ++ di_read_unlock(a->src_parent, AuLock_IR); ++ return err; ++} ++ ++static int au_cpup_or_link(struct dentry *src_dentry, struct dentry *dentry, ++ struct au_link_args *a) ++{ ++ int err; ++ unsigned char plink; ++ aufs_bindex_t bbot; ++ struct dentry *h_src_dentry; ++ struct inode *h_inode, *inode, *delegated; ++ struct super_block *sb; ++ struct file *h_file; ++ ++ plink = 0; ++ h_inode = NULL; ++ sb = src_dentry->d_sb; ++ inode = d_inode(src_dentry); ++ if (au_ibtop(inode) <= a->bdst) ++ h_inode = au_h_iptr(inode, a->bdst); ++ if (!h_inode || !h_inode->i_nlink) { ++ /* copyup src_dentry as the name of dentry. */ ++ bbot = au_dbbot(dentry); ++ if (bbot < a->bsrc) ++ au_set_dbbot(dentry, a->bsrc); ++ au_set_h_dptr(dentry, a->bsrc, ++ dget(au_h_dptr(src_dentry, a->bsrc))); ++ dget(a->h_path.dentry); ++ au_set_h_dptr(dentry, a->bdst, NULL); ++ AuDbg("temporary d_inode...\n"); ++ spin_lock(&dentry->d_lock); ++ dentry->d_inode = d_inode(src_dentry); /* tmp */ ++ spin_unlock(&dentry->d_lock); ++ h_file = au_h_open_pre(dentry, a->bsrc, /*force_wr*/0); ++ if (IS_ERR(h_file)) ++ err = PTR_ERR(h_file); ++ else { ++ struct au_cp_generic cpg = { ++ .dentry = dentry, ++ .bdst = a->bdst, ++ .bsrc = -1, ++ .len = -1, ++ .pin = &a->pin, ++ .flags = AuCpup_KEEPLINO ++ }; ++ err = au_sio_cpup_simple(&cpg); ++ au_h_open_post(dentry, a->bsrc, h_file); ++ if (!err) { ++ dput(a->h_path.dentry); ++ a->h_path.dentry = au_h_dptr(dentry, a->bdst); ++ } else ++ au_set_h_dptr(dentry, a->bdst, ++ a->h_path.dentry); ++ } ++ spin_lock(&dentry->d_lock); ++ dentry->d_inode = NULL; /* restore */ ++ spin_unlock(&dentry->d_lock); ++ AuDbg("temporary d_inode...done\n"); ++ au_set_h_dptr(dentry, a->bsrc, NULL); ++ au_set_dbbot(dentry, bbot); ++ } else { ++ /* the inode of src_dentry already exists on a.bdst branch */ ++ h_src_dentry = d_find_alias(h_inode); ++ if (!h_src_dentry && au_plink_test(inode)) { ++ plink = 1; ++ h_src_dentry = au_plink_lkup(inode, a->bdst); ++ err = PTR_ERR(h_src_dentry); ++ if (IS_ERR(h_src_dentry)) ++ goto out; ++ ++ if (unlikely(d_is_negative(h_src_dentry))) { ++ dput(h_src_dentry); ++ h_src_dentry = NULL; ++ } ++ ++ } ++ if (h_src_dentry) { ++ delegated = NULL; ++ err = vfsub_link(h_src_dentry, au_pinned_h_dir(&a->pin), ++ &a->h_path, &delegated); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal link\n"); ++ iput(delegated); ++ } ++ dput(h_src_dentry); ++ } else { ++ AuIOErr("no dentry found for hi%lu on b%d\n", ++ h_inode->i_ino, a->bdst); ++ err = -EIO; ++ } ++ } ++ ++ if (!err && !plink) ++ au_plink_append(inode, a->bdst, a->h_path.dentry); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int aufs_link(struct dentry *src_dentry, struct inode *dir, ++ struct dentry *dentry) ++{ ++ int err, rerr; ++ struct au_dtime dt; ++ struct au_link_args *a; ++ struct dentry *wh_dentry, *h_src_dentry; ++ struct inode *inode, *delegated; ++ struct super_block *sb; ++ struct au_wr_dir_args wr_dir_args = { ++ /* .force_btgt = -1, */ ++ .flags = AuWrDir_ADD_ENTRY ++ }; ++ ++ IMustLock(dir); ++ inode = d_inode(src_dentry); ++ IMustLock(inode); ++ ++ err = -ENOMEM; ++ a = kzalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ a->parent = dentry->d_parent; /* dir inode is locked */ ++ err = aufs_read_and_write_lock2(dentry, src_dentry, ++ AuLock_NOPLM | AuLock_GEN); ++ if (unlikely(err)) ++ goto out_kfree; ++ err = au_d_linkable(src_dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ err = au_d_may_add(dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ a->src_parent = dget_parent(src_dentry); ++ wr_dir_args.force_btgt = au_ibtop(inode); ++ ++ di_write_lock_parent(a->parent); ++ wr_dir_args.force_btgt = au_wbr(dentry, wr_dir_args.force_btgt); ++ wh_dentry = lock_hdir_lkup_wh(dentry, &dt, src_dentry, &a->pin, ++ &wr_dir_args); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_parent; ++ ++ err = 0; ++ sb = dentry->d_sb; ++ a->bdst = au_dbtop(dentry); ++ a->h_path.dentry = au_h_dptr(dentry, a->bdst); ++ a->h_path.mnt = au_sbr_mnt(sb, a->bdst); ++ a->bsrc = au_ibtop(inode); ++ h_src_dentry = au_h_d_alias(src_dentry, a->bsrc); ++ if (!h_src_dentry && au_di(src_dentry)->di_tmpfile) ++ h_src_dentry = dget(au_hi_wh(inode, a->bsrc)); ++ if (!h_src_dentry) { ++ a->bsrc = au_dbtop(src_dentry); ++ h_src_dentry = au_h_d_alias(src_dentry, a->bsrc); ++ AuDebugOn(!h_src_dentry); ++ } else if (IS_ERR(h_src_dentry)) { ++ err = PTR_ERR(h_src_dentry); ++ goto out_parent; ++ } ++ ++ /* ++ * aufs doesn't touch the credential so ++ * security_dentry_create_files_as() is unnecessary. ++ */ ++ if (au_opt_test(au_mntflags(sb), PLINK)) { ++ if (a->bdst < a->bsrc ++ /* && h_src_dentry->d_sb != a->h_path.dentry->d_sb */) ++ err = au_cpup_or_link(src_dentry, dentry, a); ++ else { ++ delegated = NULL; ++ err = vfsub_link(h_src_dentry, au_pinned_h_dir(&a->pin), ++ &a->h_path, &delegated); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal link\n"); ++ iput(delegated); ++ } ++ } ++ dput(h_src_dentry); ++ } else { ++ /* ++ * copyup src_dentry to the branch we process, ++ * and then link(2) to it. ++ */ ++ dput(h_src_dentry); ++ if (a->bdst < a->bsrc ++ /* && h_src_dentry->d_sb != a->h_path.dentry->d_sb */) { ++ au_unpin(&a->pin); ++ di_write_unlock(a->parent); ++ err = au_cpup_before_link(src_dentry, a); ++ di_write_lock_parent(a->parent); ++ if (!err) ++ err = au_pin(&a->pin, dentry, a->bdst, ++ au_opt_udba(sb), ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out_wh; ++ } ++ if (!err) { ++ h_src_dentry = au_h_dptr(src_dentry, a->bdst); ++ err = -ENOENT; ++ if (h_src_dentry && d_is_positive(h_src_dentry)) { ++ delegated = NULL; ++ err = vfsub_link(h_src_dentry, ++ au_pinned_h_dir(&a->pin), ++ &a->h_path, &delegated); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry" ++ " for NFSv4 delegation" ++ " for an internal link\n"); ++ iput(delegated); ++ } ++ } ++ } ++ } ++ if (unlikely(err)) ++ goto out_unpin; ++ ++ if (wh_dentry) { ++ a->h_path.dentry = wh_dentry; ++ err = au_wh_unlink_dentry(au_pinned_h_dir(&a->pin), &a->h_path, ++ dentry); ++ if (unlikely(err)) ++ goto out_revert; ++ } ++ ++ au_dir_ts(dir, a->bdst); ++ inode_inc_iversion(dir); ++ inc_nlink(inode); ++ inode->i_ctime = dir->i_ctime; ++ d_instantiate(dentry, au_igrab(inode)); ++ if (d_unhashed(a->h_path.dentry)) ++ /* some filesystem calls d_drop() */ ++ d_drop(dentry); ++ /* some filesystems consume an inode even hardlink */ ++ au_fhsm_wrote(sb, a->bdst, /*force*/0); ++ goto out_unpin; /* success */ ++ ++out_revert: ++ /* no delegation since it is just created */ ++ rerr = vfsub_unlink(au_pinned_h_dir(&a->pin), &a->h_path, ++ /*delegated*/NULL, /*force*/0); ++ if (unlikely(rerr)) { ++ AuIOErr("%pd reverting failed(%d, %d)\n", dentry, err, rerr); ++ err = -EIO; ++ } ++ au_dtime_revert(&dt); ++out_unpin: ++ au_unpin(&a->pin); ++out_wh: ++ dput(wh_dentry); ++out_parent: ++ di_write_unlock(a->parent); ++ dput(a->src_parent); ++out_unlock: ++ if (unlikely(err)) { ++ au_update_dbtop(dentry); ++ d_drop(dentry); ++ } ++ aufs_read_and_write_unlock2(dentry, src_dentry); ++out_kfree: ++ au_kfree_rcu(a); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int aufs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) ++{ ++ int err, rerr; ++ aufs_bindex_t bindex; ++ unsigned char diropq; ++ struct path h_path; ++ struct dentry *wh_dentry, *parent, *opq_dentry; ++ struct inode *h_inode; ++ struct super_block *sb; ++ struct { ++ struct au_pin pin; ++ struct au_dtime dt; ++ } *a; /* reduce the stack usage */ ++ struct au_wr_dir_args wr_dir_args = { ++ .force_btgt = -1, ++ .flags = AuWrDir_ADD_ENTRY | AuWrDir_ISDIR ++ }; ++ ++ IMustLock(dir); ++ ++ err = -ENOMEM; ++ a = kmalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ err = aufs_read_lock(dentry, AuLock_DW | AuLock_GEN); ++ if (unlikely(err)) ++ goto out_free; ++ err = au_d_may_add(dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_write_lock_parent(parent); ++ wh_dentry = lock_hdir_lkup_wh(dentry, &a->dt, /*src_dentry*/NULL, ++ &a->pin, &wr_dir_args); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_parent; ++ ++ sb = dentry->d_sb; ++ bindex = au_dbtop(dentry); ++ h_path.dentry = au_h_dptr(dentry, bindex); ++ h_path.mnt = au_sbr_mnt(sb, bindex); ++ err = vfsub_mkdir(au_pinned_h_dir(&a->pin), &h_path, mode); ++ if (unlikely(err)) ++ goto out_unpin; ++ ++ /* make the dir opaque */ ++ diropq = 0; ++ h_inode = d_inode(h_path.dentry); ++ if (wh_dentry ++ || au_opt_test(au_mntflags(sb), ALWAYS_DIROPQ)) { ++ inode_lock_nested(h_inode, AuLsc_I_CHILD); ++ opq_dentry = au_diropq_create(dentry, bindex); ++ inode_unlock(h_inode); ++ err = PTR_ERR(opq_dentry); ++ if (IS_ERR(opq_dentry)) ++ goto out_dir; ++ dput(opq_dentry); ++ diropq = 1; ++ } ++ ++ err = epilog(dir, bindex, wh_dentry, dentry); ++ if (!err) { ++ inc_nlink(dir); ++ goto out_unpin; /* success */ ++ } ++ ++ /* revert */ ++ if (diropq) { ++ AuLabel(revert opq); ++ inode_lock_nested(h_inode, AuLsc_I_CHILD); ++ rerr = au_diropq_remove(dentry, bindex); ++ inode_unlock(h_inode); ++ if (rerr) { ++ AuIOErr("%pd reverting diropq failed(%d, %d)\n", ++ dentry, err, rerr); ++ err = -EIO; ++ } ++ } ++ ++out_dir: ++ AuLabel(revert dir); ++ rerr = vfsub_rmdir(au_pinned_h_dir(&a->pin), &h_path); ++ if (rerr) { ++ AuIOErr("%pd reverting dir failed(%d, %d)\n", ++ dentry, err, rerr); ++ err = -EIO; ++ } ++ au_dtime_revert(&a->dt); ++out_unpin: ++ au_unpin(&a->pin); ++ dput(wh_dentry); ++out_parent: ++ di_write_unlock(parent); ++out_unlock: ++ if (unlikely(err)) { ++ au_update_dbtop(dentry); ++ d_drop(dentry); ++ } ++ aufs_read_unlock(dentry, AuLock_DW); ++out_free: ++ au_kfree_rcu(a); ++out: ++ return err; ++} +diff --git a/fs/aufs/i_op_del.c b/fs/aufs/i_op_del.c +new file mode 100644 +index 000000000000..05f5d4219b41 +--- /dev/null ++++ b/fs/aufs/i_op_del.c +@@ -0,0 +1,500 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * inode operations (del entry) ++ */ ++ ++#include ++#include "aufs.h" ++ ++/* ++ * decide if a new whiteout for @dentry is necessary or not. ++ * when it is necessary, prepare the parent dir for the upper branch whose ++ * branch index is @bcpup for creation. the actual creation of the whiteout will ++ * be done by caller. ++ * return value: ++ * 0: wh is unnecessary ++ * plus: wh is necessary ++ * minus: error ++ */ ++int au_wr_dir_need_wh(struct dentry *dentry, int isdir, aufs_bindex_t *bcpup) ++{ ++ int need_wh, err; ++ aufs_bindex_t btop; ++ struct super_block *sb; ++ ++ sb = dentry->d_sb; ++ btop = au_dbtop(dentry); ++ if (*bcpup < 0) { ++ *bcpup = btop; ++ if (au_test_ro(sb, btop, d_inode(dentry))) { ++ err = AuWbrCopyup(au_sbi(sb), dentry); ++ *bcpup = err; ++ if (unlikely(err < 0)) ++ goto out; ++ } ++ } else ++ AuDebugOn(btop < *bcpup ++ || au_test_ro(sb, *bcpup, d_inode(dentry))); ++ AuDbg("bcpup %d, btop %d\n", *bcpup, btop); ++ ++ if (*bcpup != btop) { ++ err = au_cpup_dirs(dentry, *bcpup); ++ if (unlikely(err)) ++ goto out; ++ need_wh = 1; ++ } else { ++ struct au_dinfo *dinfo, *tmp; ++ ++ need_wh = -ENOMEM; ++ dinfo = au_di(dentry); ++ tmp = au_di_alloc(sb, AuLsc_DI_TMP); ++ if (tmp) { ++ au_di_cp(tmp, dinfo); ++ au_di_swap(tmp, dinfo); ++ /* returns the number of positive dentries */ ++ need_wh = au_lkup_dentry(dentry, btop + 1, ++ /* AuLkup_IGNORE_PERM */ 0); ++ au_di_swap(tmp, dinfo); ++ au_rw_write_unlock(&tmp->di_rwsem); ++ au_di_free(tmp); ++ } ++ } ++ AuDbg("need_wh %d\n", need_wh); ++ err = need_wh; ++ ++out: ++ return err; ++} ++ ++/* ++ * simple tests for the del-entry operations. ++ * following the checks in vfs, plus the parent-child relationship. ++ */ ++int au_may_del(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir) ++{ ++ int err; ++ umode_t h_mode; ++ struct dentry *h_dentry, *h_latest; ++ struct inode *h_inode; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (d_really_is_positive(dentry)) { ++ err = -ENOENT; ++ if (unlikely(d_is_negative(h_dentry))) ++ goto out; ++ h_inode = d_inode(h_dentry); ++ if (unlikely(!h_inode->i_nlink)) ++ goto out; ++ ++ h_mode = h_inode->i_mode; ++ if (!isdir) { ++ err = -EISDIR; ++ if (unlikely(S_ISDIR(h_mode))) ++ goto out; ++ } else if (unlikely(!S_ISDIR(h_mode))) { ++ err = -ENOTDIR; ++ goto out; ++ } ++ } else { ++ /* rename(2) case */ ++ err = -EIO; ++ if (unlikely(d_is_positive(h_dentry))) ++ goto out; ++ } ++ ++ err = -ENOENT; ++ /* expected parent dir is locked */ ++ if (unlikely(h_parent != h_dentry->d_parent)) ++ goto out; ++ err = 0; ++ ++ /* ++ * rmdir a dir may break the consistency on some filesystem. ++ * let's try heavy test. ++ */ ++ err = -EACCES; ++ if (unlikely(!au_opt_test(au_mntflags(dentry->d_sb), DIRPERM1) ++ && au_test_h_perm(d_inode(h_parent), ++ MAY_EXEC | MAY_WRITE))) ++ goto out; ++ ++ h_latest = au_sio_lkup_one(&dentry->d_name, h_parent); ++ err = -EIO; ++ if (IS_ERR(h_latest)) ++ goto out; ++ if (h_latest == h_dentry) ++ err = 0; ++ dput(h_latest); ++ ++out: ++ return err; ++} ++ ++/* ++ * decide the branch where we operate for @dentry. the branch index will be set ++ * @rbcpup. after deciding it, 'pin' it and store the timestamps of the parent ++ * dir for reverting. ++ * when a new whiteout is necessary, create it. ++ */ ++static struct dentry* ++lock_hdir_create_wh(struct dentry *dentry, int isdir, aufs_bindex_t *rbcpup, ++ struct au_dtime *dt, struct au_pin *pin) ++{ ++ struct dentry *wh_dentry; ++ struct super_block *sb; ++ struct path h_path; ++ int err, need_wh; ++ unsigned int udba; ++ aufs_bindex_t bcpup; ++ ++ need_wh = au_wr_dir_need_wh(dentry, isdir, rbcpup); ++ wh_dentry = ERR_PTR(need_wh); ++ if (unlikely(need_wh < 0)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ udba = au_opt_udba(sb); ++ bcpup = *rbcpup; ++ err = au_pin(pin, dentry, bcpup, udba, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ h_path.dentry = au_pinned_h_parent(pin); ++ if (udba != AuOpt_UDBA_NONE ++ && au_dbtop(dentry) == bcpup) { ++ err = au_may_del(dentry, bcpup, h_path.dentry, isdir); ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_unpin; ++ } ++ ++ h_path.mnt = au_sbr_mnt(sb, bcpup); ++ au_dtime_store(dt, au_pinned_parent(pin), &h_path); ++ wh_dentry = NULL; ++ if (!need_wh) ++ goto out; /* success, no need to create whiteout */ ++ ++ wh_dentry = au_wh_create(dentry, bcpup, h_path.dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_unpin; ++ ++ /* returns with the parent is locked and wh_dentry is dget-ed */ ++ goto out; /* success */ ++ ++out_unpin: ++ au_unpin(pin); ++out: ++ return wh_dentry; ++} ++ ++/* ++ * when removing a dir, rename it to a unique temporary whiteout-ed name first ++ * in order to be revertible and save time for removing many child whiteouts ++ * under the dir. ++ * returns 1 when there are too many child whiteout and caller should remove ++ * them asynchronously. returns 0 when the number of children is enough small to ++ * remove now or the branch fs is a remote fs. ++ * otherwise return an error. ++ */ ++static int renwh_and_rmdir(struct dentry *dentry, aufs_bindex_t bindex, ++ struct au_nhash *whlist, struct inode *dir) ++{ ++ int rmdir_later, err, dirwh; ++ struct dentry *h_dentry; ++ struct super_block *sb; ++ struct inode *inode; ++ ++ sb = dentry->d_sb; ++ SiMustAnyLock(sb); ++ h_dentry = au_h_dptr(dentry, bindex); ++ err = au_whtmp_ren(h_dentry, au_sbr(sb, bindex)); ++ if (unlikely(err)) ++ goto out; ++ ++ /* stop monitoring */ ++ inode = d_inode(dentry); ++ au_hn_free(au_hi(inode, bindex)); ++ ++ if (!au_test_fs_remote(h_dentry->d_sb)) { ++ dirwh = au_sbi(sb)->si_dirwh; ++ rmdir_later = (dirwh <= 1); ++ if (!rmdir_later) ++ rmdir_later = au_nhash_test_longer_wh(whlist, bindex, ++ dirwh); ++ if (rmdir_later) ++ return rmdir_later; ++ } ++ ++ err = au_whtmp_rmdir(dir, bindex, h_dentry, whlist); ++ if (unlikely(err)) { ++ AuIOErr("rmdir %pd, b%d failed, %d. ignored\n", ++ h_dentry, bindex, err); ++ err = 0; ++ } ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ++ * final procedure for deleting a entry. ++ * maintain dentry and iattr. ++ */ ++static void epilog(struct inode *dir, struct dentry *dentry, ++ aufs_bindex_t bindex) ++{ ++ struct inode *inode; ++ ++ inode = d_inode(dentry); ++ d_drop(dentry); ++ inode->i_ctime = dir->i_ctime; ++ ++ au_dir_ts(dir, bindex); ++ inode_inc_iversion(dir); ++} ++ ++/* ++ * when an error happened, remove the created whiteout and revert everything. ++ */ ++static int do_revert(int err, struct inode *dir, aufs_bindex_t bindex, ++ aufs_bindex_t bwh, struct dentry *wh_dentry, ++ struct dentry *dentry, struct au_dtime *dt) ++{ ++ int rerr; ++ struct path h_path = { ++ .dentry = wh_dentry, ++ .mnt = au_sbr_mnt(dir->i_sb, bindex) ++ }; ++ ++ rerr = au_wh_unlink_dentry(au_h_iptr(dir, bindex), &h_path, dentry); ++ if (!rerr) { ++ au_set_dbwh(dentry, bwh); ++ au_dtime_revert(dt); ++ return 0; ++ } ++ ++ AuIOErr("%pd reverting whiteout failed(%d, %d)\n", dentry, err, rerr); ++ return -EIO; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int aufs_unlink(struct inode *dir, struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t bwh, bindex, btop; ++ struct inode *inode, *h_dir, *delegated; ++ struct dentry *parent, *wh_dentry; ++ /* to reduce stack size */ ++ struct { ++ struct au_dtime dt; ++ struct au_pin pin; ++ struct path h_path; ++ } *a; ++ ++ IMustLock(dir); ++ ++ err = -ENOMEM; ++ a = kmalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ err = aufs_read_lock(dentry, AuLock_DW | AuLock_GEN); ++ if (unlikely(err)) ++ goto out_free; ++ err = au_d_hashed_positive(dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ inode = d_inode(dentry); ++ IMustLock(inode); ++ err = -EISDIR; ++ if (unlikely(d_is_dir(dentry))) ++ goto out_unlock; /* possible? */ ++ ++ btop = au_dbtop(dentry); ++ bwh = au_dbwh(dentry); ++ bindex = -1; ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_write_lock_parent(parent); ++ wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/0, &bindex, &a->dt, ++ &a->pin); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_parent; ++ ++ a->h_path.mnt = au_sbr_mnt(dentry->d_sb, btop); ++ a->h_path.dentry = au_h_dptr(dentry, btop); ++ dget(a->h_path.dentry); ++ if (bindex == btop) { ++ h_dir = au_pinned_h_dir(&a->pin); ++ delegated = NULL; ++ err = vfsub_unlink(h_dir, &a->h_path, &delegated, /*force*/0); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ } else { ++ /* dir inode is locked */ ++ h_dir = d_inode(wh_dentry->d_parent); ++ IMustLock(h_dir); ++ err = 0; ++ } ++ ++ if (!err) { ++ vfsub_drop_nlink(inode); ++ epilog(dir, dentry, bindex); ++ ++ /* update target timestamps */ ++ if (bindex == btop) { ++ vfsub_update_h_iattr(&a->h_path, /*did*/NULL); ++ /*ignore*/ ++ inode->i_ctime = d_inode(a->h_path.dentry)->i_ctime; ++ } else ++ /* todo: this timestamp may be reverted later */ ++ inode->i_ctime = h_dir->i_ctime; ++ goto out_unpin; /* success */ ++ } ++ ++ /* revert */ ++ if (wh_dentry) { ++ int rerr; ++ ++ rerr = do_revert(err, dir, bindex, bwh, wh_dentry, dentry, ++ &a->dt); ++ if (rerr) ++ err = rerr; ++ } ++ ++out_unpin: ++ au_unpin(&a->pin); ++ dput(wh_dentry); ++ dput(a->h_path.dentry); ++out_parent: ++ di_write_unlock(parent); ++out_unlock: ++ aufs_read_unlock(dentry, AuLock_DW); ++out_free: ++ au_kfree_rcu(a); ++out: ++ return err; ++} ++ ++int aufs_rmdir(struct inode *dir, struct dentry *dentry) ++{ ++ int err, rmdir_later; ++ aufs_bindex_t bwh, bindex, btop; ++ struct inode *inode; ++ struct dentry *parent, *wh_dentry, *h_dentry; ++ struct au_whtmp_rmdir *args; ++ /* to reduce stack size */ ++ struct { ++ struct au_dtime dt; ++ struct au_pin pin; ++ } *a; ++ ++ IMustLock(dir); ++ ++ err = -ENOMEM; ++ a = kmalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ err = aufs_read_lock(dentry, AuLock_DW | AuLock_FLUSH | AuLock_GEN); ++ if (unlikely(err)) ++ goto out_free; ++ err = au_alive_dir(dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ inode = d_inode(dentry); ++ IMustLock(inode); ++ err = -ENOTDIR; ++ if (unlikely(!d_is_dir(dentry))) ++ goto out_unlock; /* possible? */ ++ ++ err = -ENOMEM; ++ args = au_whtmp_rmdir_alloc(dir->i_sb, GFP_NOFS); ++ if (unlikely(!args)) ++ goto out_unlock; ++ ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_write_lock_parent(parent); ++ err = au_test_empty(dentry, &args->whlist); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ btop = au_dbtop(dentry); ++ bwh = au_dbwh(dentry); ++ bindex = -1; ++ wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/1, &bindex, &a->dt, ++ &a->pin); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_parent; ++ ++ h_dentry = au_h_dptr(dentry, btop); ++ dget(h_dentry); ++ rmdir_later = 0; ++ if (bindex == btop) { ++ err = renwh_and_rmdir(dentry, btop, &args->whlist, dir); ++ if (err > 0) { ++ rmdir_later = err; ++ err = 0; ++ } ++ } else { ++ /* stop monitoring */ ++ au_hn_free(au_hi(inode, btop)); ++ ++ /* dir inode is locked */ ++ IMustLock(d_inode(wh_dentry->d_parent)); ++ err = 0; ++ } ++ ++ if (!err) { ++ vfsub_dead_dir(inode); ++ au_set_dbdiropq(dentry, -1); ++ epilog(dir, dentry, bindex); ++ ++ if (rmdir_later) { ++ au_whtmp_kick_rmdir(dir, btop, h_dentry, args); ++ args = NULL; ++ } ++ ++ goto out_unpin; /* success */ ++ } ++ ++ /* revert */ ++ AuLabel(revert); ++ if (wh_dentry) { ++ int rerr; ++ ++ rerr = do_revert(err, dir, bindex, bwh, wh_dentry, dentry, ++ &a->dt); ++ if (rerr) ++ err = rerr; ++ } ++ ++out_unpin: ++ au_unpin(&a->pin); ++ dput(wh_dentry); ++ dput(h_dentry); ++out_parent: ++ di_write_unlock(parent); ++ if (args) ++ au_whtmp_rmdir_free(args); ++out_unlock: ++ aufs_read_unlock(dentry, AuLock_DW); ++out_free: ++ au_kfree_rcu(a); ++out: ++ AuTraceErr(err); ++ return err; ++} +diff --git a/fs/aufs/i_op_ren.c b/fs/aufs/i_op_ren.c +new file mode 100644 +index 000000000000..37c52390034a +--- /dev/null ++++ b/fs/aufs/i_op_ren.c +@@ -0,0 +1,1237 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * inode operation (rename entry) ++ * todo: this is crazy monster ++ */ ++ ++#include ++#include "aufs.h" ++ ++enum { AuSRC, AuDST, AuSrcDst }; ++enum { AuPARENT, AuCHILD, AuParentChild }; ++ ++#define AuRen_ISDIR_SRC 1 ++#define AuRen_ISDIR_DST (1 << 1) ++#define AuRen_ISSAMEDIR (1 << 2) ++#define AuRen_WHSRC (1 << 3) ++#define AuRen_WHDST (1 << 4) ++#define AuRen_MNT_WRITE (1 << 5) ++#define AuRen_DT_DSTDIR (1 << 6) ++#define AuRen_DIROPQ_SRC (1 << 7) ++#define AuRen_DIROPQ_DST (1 << 8) ++#define AuRen_DIRREN (1 << 9) ++#define AuRen_DROPPED_SRC (1 << 10) ++#define AuRen_DROPPED_DST (1 << 11) ++#define au_ftest_ren(flags, name) ((flags) & AuRen_##name) ++#define au_fset_ren(flags, name) \ ++ do { (flags) |= AuRen_##name; } while (0) ++#define au_fclr_ren(flags, name) \ ++ do { (flags) &= ~AuRen_##name; } while (0) ++ ++#ifndef CONFIG_AUFS_DIRREN ++#undef AuRen_DIRREN ++#define AuRen_DIRREN 0 ++#endif ++ ++struct au_ren_args { ++ struct { ++ struct dentry *dentry, *h_dentry, *parent, *h_parent, ++ *wh_dentry; ++ struct inode *dir, *inode; ++ struct au_hinode *hdir, *hinode; ++ struct au_dtime dt[AuParentChild]; ++ aufs_bindex_t btop, bdiropq; ++ } sd[AuSrcDst]; ++ ++#define src_dentry sd[AuSRC].dentry ++#define src_dir sd[AuSRC].dir ++#define src_inode sd[AuSRC].inode ++#define src_h_dentry sd[AuSRC].h_dentry ++#define src_parent sd[AuSRC].parent ++#define src_h_parent sd[AuSRC].h_parent ++#define src_wh_dentry sd[AuSRC].wh_dentry ++#define src_hdir sd[AuSRC].hdir ++#define src_hinode sd[AuSRC].hinode ++#define src_h_dir sd[AuSRC].hdir->hi_inode ++#define src_dt sd[AuSRC].dt ++#define src_btop sd[AuSRC].btop ++#define src_bdiropq sd[AuSRC].bdiropq ++ ++#define dst_dentry sd[AuDST].dentry ++#define dst_dir sd[AuDST].dir ++#define dst_inode sd[AuDST].inode ++#define dst_h_dentry sd[AuDST].h_dentry ++#define dst_parent sd[AuDST].parent ++#define dst_h_parent sd[AuDST].h_parent ++#define dst_wh_dentry sd[AuDST].wh_dentry ++#define dst_hdir sd[AuDST].hdir ++#define dst_hinode sd[AuDST].hinode ++#define dst_h_dir sd[AuDST].hdir->hi_inode ++#define dst_dt sd[AuDST].dt ++#define dst_btop sd[AuDST].btop ++#define dst_bdiropq sd[AuDST].bdiropq ++ ++ struct dentry *h_trap; ++ struct au_branch *br; ++ struct path h_path; ++ struct au_nhash whlist; ++ aufs_bindex_t btgt, src_bwh; ++ ++ struct { ++ unsigned short auren_flags; ++ unsigned char flags; /* syscall parameter */ ++ unsigned char exchange; ++ } __packed; ++ ++ struct au_whtmp_rmdir *thargs; ++ struct dentry *h_dst; ++ struct au_hinode *h_root; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * functions for reverting. ++ * when an error happened in a single rename systemcall, we should revert ++ * everything as if nothing happened. ++ * we don't need to revert the copied-up/down the parent dir since they are ++ * harmless. ++ */ ++ ++#define RevertFailure(fmt, ...) do { \ ++ AuIOErr("revert failure: " fmt " (%d, %d)\n", \ ++ ##__VA_ARGS__, err, rerr); \ ++ err = -EIO; \ ++} while (0) ++ ++static void au_ren_do_rev_diropq(int err, struct au_ren_args *a, int idx) ++{ ++ int rerr; ++ struct dentry *d; ++#define src_or_dst(member) a->sd[idx].member ++ ++ d = src_or_dst(dentry); /* {src,dst}_dentry */ ++ au_hn_inode_lock_nested(src_or_dst(hinode), AuLsc_I_CHILD); ++ rerr = au_diropq_remove(d, a->btgt); ++ au_hn_inode_unlock(src_or_dst(hinode)); ++ au_set_dbdiropq(d, src_or_dst(bdiropq)); ++ if (rerr) ++ RevertFailure("remove diropq %pd", d); ++ ++#undef src_or_dst_ ++} ++ ++static void au_ren_rev_diropq(int err, struct au_ren_args *a) ++{ ++ if (au_ftest_ren(a->auren_flags, DIROPQ_SRC)) ++ au_ren_do_rev_diropq(err, a, AuSRC); ++ if (au_ftest_ren(a->auren_flags, DIROPQ_DST)) ++ au_ren_do_rev_diropq(err, a, AuDST); ++} ++ ++static void au_ren_rev_rename(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ struct inode *delegated; ++ ++ a->h_path.dentry = vfsub_lkup_one(&a->src_dentry->d_name, ++ a->src_h_parent); ++ rerr = PTR_ERR(a->h_path.dentry); ++ if (IS_ERR(a->h_path.dentry)) { ++ RevertFailure("lkup one %pd", a->src_dentry); ++ return; ++ } ++ ++ delegated = NULL; ++ rerr = vfsub_rename(a->dst_h_dir, ++ au_h_dptr(a->src_dentry, a->btgt), ++ a->src_h_dir, &a->h_path, &delegated, a->flags); ++ if (unlikely(rerr == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal rename\n"); ++ iput(delegated); ++ } ++ d_drop(a->h_path.dentry); ++ dput(a->h_path.dentry); ++ /* au_set_h_dptr(a->src_dentry, a->btgt, NULL); */ ++ if (rerr) ++ RevertFailure("rename %pd", a->src_dentry); ++} ++ ++static void au_ren_rev_whtmp(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ struct inode *delegated; ++ ++ a->h_path.dentry = vfsub_lkup_one(&a->dst_dentry->d_name, ++ a->dst_h_parent); ++ rerr = PTR_ERR(a->h_path.dentry); ++ if (IS_ERR(a->h_path.dentry)) { ++ RevertFailure("lkup one %pd", a->dst_dentry); ++ return; ++ } ++ if (d_is_positive(a->h_path.dentry)) { ++ d_drop(a->h_path.dentry); ++ dput(a->h_path.dentry); ++ return; ++ } ++ ++ delegated = NULL; ++ rerr = vfsub_rename(a->dst_h_dir, a->h_dst, a->dst_h_dir, &a->h_path, ++ &delegated, a->flags); ++ if (unlikely(rerr == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal rename\n"); ++ iput(delegated); ++ } ++ d_drop(a->h_path.dentry); ++ dput(a->h_path.dentry); ++ if (!rerr) ++ au_set_h_dptr(a->dst_dentry, a->btgt, dget(a->h_dst)); ++ else ++ RevertFailure("rename %pd", a->h_dst); ++} ++ ++static void au_ren_rev_whsrc(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ ++ a->h_path.dentry = a->src_wh_dentry; ++ rerr = au_wh_unlink_dentry(a->src_h_dir, &a->h_path, a->src_dentry); ++ au_set_dbwh(a->src_dentry, a->src_bwh); ++ if (rerr) ++ RevertFailure("unlink %pd", a->src_wh_dentry); ++} ++#undef RevertFailure ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * when we have to copyup the renaming entry, do it with the rename-target name ++ * in order to minimize the cost (the later actual rename is unnecessary). ++ * otherwise rename it on the target branch. ++ */ ++static int au_ren_or_cpup(struct au_ren_args *a) ++{ ++ int err; ++ struct dentry *d; ++ struct inode *delegated; ++ ++ d = a->src_dentry; ++ if (au_dbtop(d) == a->btgt) { ++ a->h_path.dentry = a->dst_h_dentry; ++ AuDebugOn(au_dbtop(d) != a->btgt); ++ delegated = NULL; ++ err = vfsub_rename(a->src_h_dir, au_h_dptr(d, a->btgt), ++ a->dst_h_dir, &a->h_path, &delegated, ++ a->flags); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal rename\n"); ++ iput(delegated); ++ } ++ } else ++ BUG(); ++ ++ if (!err && a->h_dst) ++ /* it will be set to dinfo later */ ++ dget(a->h_dst); ++ ++ return err; ++} ++ ++/* cf. aufs_rmdir() */ ++static int au_ren_del_whtmp(struct au_ren_args *a) ++{ ++ int err; ++ struct inode *dir; ++ ++ dir = a->dst_dir; ++ SiMustAnyLock(dir->i_sb); ++ if (!au_nhash_test_longer_wh(&a->whlist, a->btgt, ++ au_sbi(dir->i_sb)->si_dirwh) ++ || au_test_fs_remote(a->h_dst->d_sb)) { ++ err = au_whtmp_rmdir(dir, a->btgt, a->h_dst, &a->whlist); ++ if (unlikely(err)) ++ pr_warn("failed removing whtmp dir %pd (%d), " ++ "ignored.\n", a->h_dst, err); ++ } else { ++ au_nhash_wh_free(&a->thargs->whlist); ++ a->thargs->whlist = a->whlist; ++ a->whlist.nh_num = 0; ++ au_whtmp_kick_rmdir(dir, a->btgt, a->h_dst, a->thargs); ++ dput(a->h_dst); ++ a->thargs = NULL; ++ } ++ ++ return 0; ++} ++ ++/* make it 'opaque' dir. */ ++static int au_ren_do_diropq(struct au_ren_args *a, int idx) ++{ ++ int err; ++ struct dentry *d, *diropq; ++#define src_or_dst(member) a->sd[idx].member ++ ++ err = 0; ++ d = src_or_dst(dentry); /* {src,dst}_dentry */ ++ src_or_dst(bdiropq) = au_dbdiropq(d); ++ src_or_dst(hinode) = au_hi(src_or_dst(inode), a->btgt); ++ au_hn_inode_lock_nested(src_or_dst(hinode), AuLsc_I_CHILD); ++ diropq = au_diropq_create(d, a->btgt); ++ au_hn_inode_unlock(src_or_dst(hinode)); ++ if (IS_ERR(diropq)) ++ err = PTR_ERR(diropq); ++ else ++ dput(diropq); ++ ++#undef src_or_dst_ ++ return err; ++} ++ ++static int au_ren_diropq(struct au_ren_args *a) ++{ ++ int err; ++ unsigned char always; ++ struct dentry *d; ++ ++ err = 0; ++ d = a->dst_dentry; /* already renamed on the branch */ ++ always = !!au_opt_test(au_mntflags(d->d_sb), ALWAYS_DIROPQ); ++ if (au_ftest_ren(a->auren_flags, ISDIR_SRC) ++ && !au_ftest_ren(a->auren_flags, DIRREN) ++ && a->btgt != au_dbdiropq(a->src_dentry) ++ && (a->dst_wh_dentry ++ || a->btgt <= au_dbdiropq(d) ++ /* hide the lower to keep xino */ ++ /* the lowers may not be a dir, but we hide them anyway */ ++ || a->btgt < au_dbbot(d) ++ || always)) { ++ AuDbg("here\n"); ++ err = au_ren_do_diropq(a, AuSRC); ++ if (unlikely(err)) ++ goto out; ++ au_fset_ren(a->auren_flags, DIROPQ_SRC); ++ } ++ if (!a->exchange) ++ goto out; /* success */ ++ ++ d = a->src_dentry; /* already renamed on the branch */ ++ if (au_ftest_ren(a->auren_flags, ISDIR_DST) ++ && a->btgt != au_dbdiropq(a->dst_dentry) ++ && (a->btgt < au_dbdiropq(d) ++ || a->btgt < au_dbbot(d) ++ || always)) { ++ AuDbgDentry(a->src_dentry); ++ AuDbgDentry(a->dst_dentry); ++ err = au_ren_do_diropq(a, AuDST); ++ if (unlikely(err)) ++ goto out_rev_src; ++ au_fset_ren(a->auren_flags, DIROPQ_DST); ++ } ++ goto out; /* success */ ++ ++out_rev_src: ++ AuDbg("err %d, reverting src\n", err); ++ au_ren_rev_diropq(err, a); ++out: ++ return err; ++} ++ ++static int do_rename(struct au_ren_args *a) ++{ ++ int err; ++ struct dentry *d, *h_d; ++ ++ if (!a->exchange) { ++ /* prepare workqueue args for asynchronous rmdir */ ++ h_d = a->dst_h_dentry; ++ if (au_ftest_ren(a->auren_flags, ISDIR_DST) ++ /* && !au_ftest_ren(a->auren_flags, DIRREN) */ ++ && d_is_positive(h_d)) { ++ err = -ENOMEM; ++ a->thargs = au_whtmp_rmdir_alloc(a->src_dentry->d_sb, ++ GFP_NOFS); ++ if (unlikely(!a->thargs)) ++ goto out; ++ a->h_dst = dget(h_d); ++ } ++ ++ /* create whiteout for src_dentry */ ++ if (au_ftest_ren(a->auren_flags, WHSRC)) { ++ a->src_bwh = au_dbwh(a->src_dentry); ++ AuDebugOn(a->src_bwh >= 0); ++ a->src_wh_dentry = au_wh_create(a->src_dentry, a->btgt, ++ a->src_h_parent); ++ err = PTR_ERR(a->src_wh_dentry); ++ if (IS_ERR(a->src_wh_dentry)) ++ goto out_thargs; ++ } ++ ++ /* lookup whiteout for dentry */ ++ if (au_ftest_ren(a->auren_flags, WHDST)) { ++ h_d = au_wh_lkup(a->dst_h_parent, ++ &a->dst_dentry->d_name, a->br); ++ err = PTR_ERR(h_d); ++ if (IS_ERR(h_d)) ++ goto out_whsrc; ++ if (d_is_negative(h_d)) ++ dput(h_d); ++ else ++ a->dst_wh_dentry = h_d; ++ } ++ ++ /* rename dentry to tmpwh */ ++ if (a->thargs) { ++ err = au_whtmp_ren(a->dst_h_dentry, a->br); ++ if (unlikely(err)) ++ goto out_whdst; ++ ++ d = a->dst_dentry; ++ au_set_h_dptr(d, a->btgt, NULL); ++ err = au_lkup_neg(d, a->btgt, /*wh*/0); ++ if (unlikely(err)) ++ goto out_whtmp; ++ a->dst_h_dentry = au_h_dptr(d, a->btgt); ++ } ++ } ++ ++ BUG_ON(d_is_positive(a->dst_h_dentry) && a->src_btop != a->btgt); ++#if 0 /* debugging */ ++ BUG_ON(!au_ftest_ren(a->auren_flags, DIRREN) ++ && d_is_positive(a->dst_h_dentry) ++ && a->src_btop != a->btgt); ++#endif ++ ++ /* rename by vfs_rename or cpup */ ++ err = au_ren_or_cpup(a); ++ if (unlikely(err)) ++ /* leave the copied-up one */ ++ goto out_whtmp; ++ ++ /* make dir opaque */ ++ err = au_ren_diropq(a); ++ if (unlikely(err)) ++ goto out_rename; ++ ++ /* update target timestamps */ ++ if (a->exchange) { ++ AuDebugOn(au_dbtop(a->dst_dentry) != a->btgt); ++ a->h_path.dentry = au_h_dptr(a->dst_dentry, a->btgt); ++ vfsub_update_h_iattr(&a->h_path, /*did*/NULL); /*ignore*/ ++ a->dst_inode->i_ctime = d_inode(a->h_path.dentry)->i_ctime; ++ } ++ AuDebugOn(au_dbtop(a->src_dentry) != a->btgt); ++ a->h_path.dentry = au_h_dptr(a->src_dentry, a->btgt); ++ vfsub_update_h_iattr(&a->h_path, /*did*/NULL); /*ignore*/ ++ a->src_inode->i_ctime = d_inode(a->h_path.dentry)->i_ctime; ++ ++ if (!a->exchange) { ++ /* remove whiteout for dentry */ ++ if (a->dst_wh_dentry) { ++ a->h_path.dentry = a->dst_wh_dentry; ++ err = au_wh_unlink_dentry(a->dst_h_dir, &a->h_path, ++ a->dst_dentry); ++ if (unlikely(err)) ++ goto out_diropq; ++ } ++ ++ /* remove whtmp */ ++ if (a->thargs) ++ au_ren_del_whtmp(a); /* ignore this error */ ++ ++ au_fhsm_wrote(a->src_dentry->d_sb, a->btgt, /*force*/0); ++ } ++ err = 0; ++ goto out_success; ++ ++out_diropq: ++ au_ren_rev_diropq(err, a); ++out_rename: ++ au_ren_rev_rename(err, a); ++ dput(a->h_dst); ++out_whtmp: ++ if (a->thargs) ++ au_ren_rev_whtmp(err, a); ++out_whdst: ++ dput(a->dst_wh_dentry); ++ a->dst_wh_dentry = NULL; ++out_whsrc: ++ if (a->src_wh_dentry) ++ au_ren_rev_whsrc(err, a); ++out_success: ++ dput(a->src_wh_dentry); ++ dput(a->dst_wh_dentry); ++out_thargs: ++ if (a->thargs) { ++ dput(a->h_dst); ++ au_whtmp_rmdir_free(a->thargs); ++ a->thargs = NULL; ++ } ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * test if @dentry dir can be rename destination or not. ++ * success means, it is a logically empty dir. ++ */ ++static int may_rename_dstdir(struct dentry *dentry, struct au_nhash *whlist) ++{ ++ return au_test_empty(dentry, whlist); ++} ++ ++/* ++ * test if @a->src_dentry dir can be rename source or not. ++ * if it can, return 0. ++ * success means, ++ * - it is a logically empty dir. ++ * - or, it exists on writable branch and has no children including whiteouts ++ * on the lower branch unless DIRREN is on. ++ */ ++static int may_rename_srcdir(struct au_ren_args *a) ++{ ++ int err; ++ unsigned int rdhash; ++ aufs_bindex_t btop, btgt; ++ struct dentry *dentry; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++ dentry = a->src_dentry; ++ sb = dentry->d_sb; ++ sbinfo = au_sbi(sb); ++ if (au_opt_test(sbinfo->si_mntflags, DIRREN)) ++ au_fset_ren(a->auren_flags, DIRREN); ++ ++ btgt = a->btgt; ++ btop = au_dbtop(dentry); ++ if (btop != btgt) { ++ struct au_nhash whlist; ++ ++ SiMustAnyLock(sb); ++ rdhash = sbinfo->si_rdhash; ++ if (!rdhash) ++ rdhash = au_rdhash_est(au_dir_size(/*file*/NULL, ++ dentry)); ++ err = au_nhash_alloc(&whlist, rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_test_empty(dentry, &whlist); ++ au_nhash_wh_free(&whlist); ++ goto out; ++ } ++ ++ if (btop == au_dbtaildir(dentry)) ++ return 0; /* success */ ++ ++ err = au_test_empty_lower(dentry); ++ ++out: ++ if (err == -ENOTEMPTY) { ++ if (au_ftest_ren(a->auren_flags, DIRREN)) { ++ err = 0; ++ } else { ++ AuWarn1("renaming dir who has child(ren) on multiple " ++ "branches, is not supported\n"); ++ err = -EXDEV; ++ } ++ } ++ return err; ++} ++ ++/* side effect: sets whlist and h_dentry */ ++static int au_ren_may_dir(struct au_ren_args *a) ++{ ++ int err; ++ unsigned int rdhash; ++ struct dentry *d; ++ ++ d = a->dst_dentry; ++ SiMustAnyLock(d->d_sb); ++ ++ err = 0; ++ if (au_ftest_ren(a->auren_flags, ISDIR_DST) && a->dst_inode) { ++ rdhash = au_sbi(d->d_sb)->si_rdhash; ++ if (!rdhash) ++ rdhash = au_rdhash_est(au_dir_size(/*file*/NULL, d)); ++ err = au_nhash_alloc(&a->whlist, rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ ++ if (!a->exchange) { ++ au_set_dbtop(d, a->dst_btop); ++ err = may_rename_dstdir(d, &a->whlist); ++ au_set_dbtop(d, a->btgt); ++ } else ++ err = may_rename_srcdir(a); ++ } ++ a->dst_h_dentry = au_h_dptr(d, au_dbtop(d)); ++ if (unlikely(err)) ++ goto out; ++ ++ d = a->src_dentry; ++ a->src_h_dentry = au_h_dptr(d, au_dbtop(d)); ++ if (au_ftest_ren(a->auren_flags, ISDIR_SRC)) { ++ err = may_rename_srcdir(a); ++ if (unlikely(err)) { ++ au_nhash_wh_free(&a->whlist); ++ a->whlist.nh_num = 0; ++ } ++ } ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * simple tests for rename. ++ * following the checks in vfs, plus the parent-child relationship. ++ */ ++static int au_may_ren(struct au_ren_args *a) ++{ ++ int err, isdir; ++ struct inode *h_inode; ++ ++ if (a->src_btop == a->btgt) { ++ err = au_may_del(a->src_dentry, a->btgt, a->src_h_parent, ++ au_ftest_ren(a->auren_flags, ISDIR_SRC)); ++ if (unlikely(err)) ++ goto out; ++ err = -EINVAL; ++ if (unlikely(a->src_h_dentry == a->h_trap)) ++ goto out; ++ } ++ ++ err = 0; ++ if (a->dst_btop != a->btgt) ++ goto out; ++ ++ err = -ENOTEMPTY; ++ if (unlikely(a->dst_h_dentry == a->h_trap)) ++ goto out; ++ ++ err = -EIO; ++ isdir = !!au_ftest_ren(a->auren_flags, ISDIR_DST); ++ if (d_really_is_negative(a->dst_dentry)) { ++ if (d_is_negative(a->dst_h_dentry)) ++ err = au_may_add(a->dst_dentry, a->btgt, ++ a->dst_h_parent, isdir); ++ } else { ++ if (unlikely(d_is_negative(a->dst_h_dentry))) ++ goto out; ++ h_inode = d_inode(a->dst_h_dentry); ++ if (h_inode->i_nlink) ++ err = au_may_del(a->dst_dentry, a->btgt, ++ a->dst_h_parent, isdir); ++ } ++ ++out: ++ if (unlikely(err == -ENOENT || err == -EEXIST)) ++ err = -EIO; ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * locking order ++ * (VFS) ++ * - src_dir and dir by lock_rename() ++ * - inode if exists ++ * (aufs) ++ * - lock all ++ * + src_dentry and dentry by aufs_read_and_write_lock2() which calls, ++ * + si_read_lock ++ * + di_write_lock2_child() ++ * + di_write_lock_child() ++ * + ii_write_lock_child() ++ * + di_write_lock_child2() ++ * + ii_write_lock_child2() ++ * + src_parent and parent ++ * + di_write_lock_parent() ++ * + ii_write_lock_parent() ++ * + di_write_lock_parent2() ++ * + ii_write_lock_parent2() ++ * + lower src_dir and dir by vfsub_lock_rename() ++ * + verify the every relationships between child and parent. if any ++ * of them failed, unlock all and return -EBUSY. ++ */ ++static void au_ren_unlock(struct au_ren_args *a) ++{ ++ vfsub_unlock_rename(a->src_h_parent, a->src_hdir, ++ a->dst_h_parent, a->dst_hdir); ++ if (au_ftest_ren(a->auren_flags, DIRREN) ++ && a->h_root) ++ au_hn_inode_unlock(a->h_root); ++ if (au_ftest_ren(a->auren_flags, MNT_WRITE)) ++ vfsub_mnt_drop_write(au_br_mnt(a->br)); ++} ++ ++static int au_ren_lock(struct au_ren_args *a) ++{ ++ int err; ++ unsigned int udba; ++ ++ err = 0; ++ a->src_h_parent = au_h_dptr(a->src_parent, a->btgt); ++ a->src_hdir = au_hi(a->src_dir, a->btgt); ++ a->dst_h_parent = au_h_dptr(a->dst_parent, a->btgt); ++ a->dst_hdir = au_hi(a->dst_dir, a->btgt); ++ ++ err = vfsub_mnt_want_write(au_br_mnt(a->br)); ++ if (unlikely(err)) ++ goto out; ++ au_fset_ren(a->auren_flags, MNT_WRITE); ++ if (au_ftest_ren(a->auren_flags, DIRREN)) { ++ struct dentry *root; ++ struct inode *dir; ++ ++ /* ++ * sbinfo is already locked, so this ii_read_lock is ++ * unnecessary. but our debugging feature checks it. ++ */ ++ root = a->src_inode->i_sb->s_root; ++ if (root != a->src_parent && root != a->dst_parent) { ++ dir = d_inode(root); ++ ii_read_lock_parent3(dir); ++ a->h_root = au_hi(dir, a->btgt); ++ ii_read_unlock(dir); ++ au_hn_inode_lock_nested(a->h_root, AuLsc_I_PARENT3); ++ } ++ } ++ a->h_trap = vfsub_lock_rename(a->src_h_parent, a->src_hdir, ++ a->dst_h_parent, a->dst_hdir); ++ udba = au_opt_udba(a->src_dentry->d_sb); ++ if (unlikely(a->src_hdir->hi_inode != d_inode(a->src_h_parent) ++ || a->dst_hdir->hi_inode != d_inode(a->dst_h_parent))) ++ err = au_busy_or_stale(); ++ if (!err && au_dbtop(a->src_dentry) == a->btgt) ++ err = au_h_verify(a->src_h_dentry, udba, ++ d_inode(a->src_h_parent), a->src_h_parent, ++ a->br); ++ if (!err && au_dbtop(a->dst_dentry) == a->btgt) ++ err = au_h_verify(a->dst_h_dentry, udba, ++ d_inode(a->dst_h_parent), a->dst_h_parent, ++ a->br); ++ if (!err) ++ goto out; /* success */ ++ ++ err = au_busy_or_stale(); ++ au_ren_unlock(a); ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_ren_refresh_dir(struct au_ren_args *a) ++{ ++ struct inode *dir; ++ ++ dir = a->dst_dir; ++ inode_inc_iversion(dir); ++ if (au_ftest_ren(a->auren_flags, ISDIR_SRC)) { ++ /* is this updating defined in POSIX? */ ++ au_cpup_attr_timesizes(a->src_inode); ++ au_cpup_attr_nlink(dir, /*force*/1); ++ } ++ au_dir_ts(dir, a->btgt); ++ ++ if (a->exchange) { ++ dir = a->src_dir; ++ inode_inc_iversion(dir); ++ if (au_ftest_ren(a->auren_flags, ISDIR_DST)) { ++ /* is this updating defined in POSIX? */ ++ au_cpup_attr_timesizes(a->dst_inode); ++ au_cpup_attr_nlink(dir, /*force*/1); ++ } ++ au_dir_ts(dir, a->btgt); ++ } ++ ++ if (au_ftest_ren(a->auren_flags, ISSAMEDIR)) ++ return; ++ ++ dir = a->src_dir; ++ inode_inc_iversion(dir); ++ if (au_ftest_ren(a->auren_flags, ISDIR_SRC)) ++ au_cpup_attr_nlink(dir, /*force*/1); ++ au_dir_ts(dir, a->btgt); ++} ++ ++static void au_ren_refresh(struct au_ren_args *a) ++{ ++ aufs_bindex_t bbot, bindex; ++ struct dentry *d, *h_d; ++ struct inode *i, *h_i; ++ struct super_block *sb; ++ ++ d = a->dst_dentry; ++ d_drop(d); ++ if (a->h_dst) ++ /* already dget-ed by au_ren_or_cpup() */ ++ au_set_h_dptr(d, a->btgt, a->h_dst); ++ ++ i = a->dst_inode; ++ if (i) { ++ if (!a->exchange) { ++ if (!au_ftest_ren(a->auren_flags, ISDIR_DST)) ++ vfsub_drop_nlink(i); ++ else { ++ vfsub_dead_dir(i); ++ au_cpup_attr_timesizes(i); ++ } ++ au_update_dbrange(d, /*do_put_zero*/1); ++ } else ++ au_cpup_attr_nlink(i, /*force*/1); ++ } else { ++ bbot = a->btgt; ++ for (bindex = au_dbtop(d); bindex < bbot; bindex++) ++ au_set_h_dptr(d, bindex, NULL); ++ bbot = au_dbbot(d); ++ for (bindex = a->btgt + 1; bindex <= bbot; bindex++) ++ au_set_h_dptr(d, bindex, NULL); ++ au_update_dbrange(d, /*do_put_zero*/0); ++ } ++ ++ if (a->exchange ++ || au_ftest_ren(a->auren_flags, DIRREN)) { ++ d_drop(a->src_dentry); ++ if (au_ftest_ren(a->auren_flags, DIRREN)) ++ au_set_dbwh(a->src_dentry, -1); ++ return; ++ } ++ ++ d = a->src_dentry; ++ au_set_dbwh(d, -1); ++ bbot = au_dbbot(d); ++ for (bindex = a->btgt + 1; bindex <= bbot; bindex++) { ++ h_d = au_h_dptr(d, bindex); ++ if (h_d) ++ au_set_h_dptr(d, bindex, NULL); ++ } ++ au_set_dbbot(d, a->btgt); ++ ++ sb = d->d_sb; ++ i = a->src_inode; ++ if (au_opt_test(au_mntflags(sb), PLINK) && au_plink_test(i)) ++ return; /* success */ ++ ++ bbot = au_ibbot(i); ++ for (bindex = a->btgt + 1; bindex <= bbot; bindex++) { ++ h_i = au_h_iptr(i, bindex); ++ if (h_i) { ++ au_xino_write(sb, bindex, h_i->i_ino, /*ino*/0); ++ /* ignore this error */ ++ au_set_h_iptr(i, bindex, NULL, 0); ++ } ++ } ++ au_set_ibbot(i, a->btgt); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* mainly for link(2) and rename(2) */ ++int au_wbr(struct dentry *dentry, aufs_bindex_t btgt) ++{ ++ aufs_bindex_t bdiropq, bwh; ++ struct dentry *parent; ++ struct au_branch *br; ++ ++ parent = dentry->d_parent; ++ IMustLock(d_inode(parent)); /* dir is locked */ ++ ++ bdiropq = au_dbdiropq(parent); ++ bwh = au_dbwh(dentry); ++ br = au_sbr(dentry->d_sb, btgt); ++ if (au_br_rdonly(br) ++ || (0 <= bdiropq && bdiropq < btgt) ++ || (0 <= bwh && bwh < btgt)) ++ btgt = -1; ++ ++ AuDbg("btgt %d\n", btgt); ++ return btgt; ++} ++ ++/* sets src_btop, dst_btop and btgt */ ++static int au_ren_wbr(struct au_ren_args *a) ++{ ++ int err; ++ struct au_wr_dir_args wr_dir_args = { ++ /* .force_btgt = -1, */ ++ .flags = AuWrDir_ADD_ENTRY ++ }; ++ ++ a->src_btop = au_dbtop(a->src_dentry); ++ a->dst_btop = au_dbtop(a->dst_dentry); ++ if (au_ftest_ren(a->auren_flags, ISDIR_SRC) ++ || au_ftest_ren(a->auren_flags, ISDIR_DST)) ++ au_fset_wrdir(wr_dir_args.flags, ISDIR); ++ wr_dir_args.force_btgt = a->src_btop; ++ if (a->dst_inode && a->dst_btop < a->src_btop) ++ wr_dir_args.force_btgt = a->dst_btop; ++ wr_dir_args.force_btgt = au_wbr(a->dst_dentry, wr_dir_args.force_btgt); ++ err = au_wr_dir(a->dst_dentry, a->src_dentry, &wr_dir_args); ++ a->btgt = err; ++ if (a->exchange) ++ au_update_dbtop(a->dst_dentry); ++ ++ return err; ++} ++ ++static void au_ren_dt(struct au_ren_args *a) ++{ ++ a->h_path.dentry = a->src_h_parent; ++ au_dtime_store(a->src_dt + AuPARENT, a->src_parent, &a->h_path); ++ if (!au_ftest_ren(a->auren_flags, ISSAMEDIR)) { ++ a->h_path.dentry = a->dst_h_parent; ++ au_dtime_store(a->dst_dt + AuPARENT, a->dst_parent, &a->h_path); ++ } ++ ++ au_fclr_ren(a->auren_flags, DT_DSTDIR); ++ if (!au_ftest_ren(a->auren_flags, ISDIR_SRC) ++ && !a->exchange) ++ return; ++ ++ a->h_path.dentry = a->src_h_dentry; ++ au_dtime_store(a->src_dt + AuCHILD, a->src_dentry, &a->h_path); ++ if (d_is_positive(a->dst_h_dentry)) { ++ au_fset_ren(a->auren_flags, DT_DSTDIR); ++ a->h_path.dentry = a->dst_h_dentry; ++ au_dtime_store(a->dst_dt + AuCHILD, a->dst_dentry, &a->h_path); ++ } ++} ++ ++static void au_ren_rev_dt(int err, struct au_ren_args *a) ++{ ++ struct dentry *h_d; ++ struct inode *h_inode; ++ ++ au_dtime_revert(a->src_dt + AuPARENT); ++ if (!au_ftest_ren(a->auren_flags, ISSAMEDIR)) ++ au_dtime_revert(a->dst_dt + AuPARENT); ++ ++ if (au_ftest_ren(a->auren_flags, ISDIR_SRC) && err != -EIO) { ++ h_d = a->src_dt[AuCHILD].dt_h_path.dentry; ++ h_inode = d_inode(h_d); ++ inode_lock_nested(h_inode, AuLsc_I_CHILD); ++ au_dtime_revert(a->src_dt + AuCHILD); ++ inode_unlock(h_inode); ++ ++ if (au_ftest_ren(a->auren_flags, DT_DSTDIR)) { ++ h_d = a->dst_dt[AuCHILD].dt_h_path.dentry; ++ h_inode = d_inode(h_d); ++ inode_lock_nested(h_inode, AuLsc_I_CHILD); ++ au_dtime_revert(a->dst_dt + AuCHILD); ++ inode_unlock(h_inode); ++ } ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int aufs_rename(struct inode *_src_dir, struct dentry *_src_dentry, ++ struct inode *_dst_dir, struct dentry *_dst_dentry, ++ unsigned int _flags) ++{ ++ int err, lock_flags; ++ void *rev; ++ /* reduce stack space */ ++ struct au_ren_args *a; ++ struct au_pin pin; ++ ++ AuDbg("%pd, %pd, 0x%x\n", _src_dentry, _dst_dentry, _flags); ++ IMustLock(_src_dir); ++ IMustLock(_dst_dir); ++ ++ err = -EINVAL; ++ if (unlikely(_flags & RENAME_WHITEOUT)) ++ goto out; ++ ++ err = -ENOMEM; ++ BUILD_BUG_ON(sizeof(*a) > PAGE_SIZE); ++ a = kzalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ a->flags = _flags; ++ BUILD_BUG_ON(sizeof(a->exchange) == sizeof(u8) ++ && RENAME_EXCHANGE > U8_MAX); ++ a->exchange = _flags & RENAME_EXCHANGE; ++ a->src_dir = _src_dir; ++ a->src_dentry = _src_dentry; ++ a->src_inode = NULL; ++ if (d_really_is_positive(a->src_dentry)) ++ a->src_inode = d_inode(a->src_dentry); ++ a->src_parent = a->src_dentry->d_parent; /* dir inode is locked */ ++ a->dst_dir = _dst_dir; ++ a->dst_dentry = _dst_dentry; ++ a->dst_inode = NULL; ++ if (d_really_is_positive(a->dst_dentry)) ++ a->dst_inode = d_inode(a->dst_dentry); ++ a->dst_parent = a->dst_dentry->d_parent; /* dir inode is locked */ ++ if (a->dst_inode) { ++ /* ++ * if EXCHANGE && src is non-dir && dst is dir, ++ * dst is not locked. ++ */ ++ /* IMustLock(a->dst_inode); */ ++ au_igrab(a->dst_inode); ++ } ++ ++ err = -ENOTDIR; ++ lock_flags = AuLock_FLUSH | AuLock_NOPLM | AuLock_GEN; ++ if (d_is_dir(a->src_dentry)) { ++ au_fset_ren(a->auren_flags, ISDIR_SRC); ++ if (unlikely(!a->exchange ++ && d_really_is_positive(a->dst_dentry) ++ && !d_is_dir(a->dst_dentry))) ++ goto out_free; ++ lock_flags |= AuLock_DIRS; ++ } ++ if (a->dst_inode && d_is_dir(a->dst_dentry)) { ++ au_fset_ren(a->auren_flags, ISDIR_DST); ++ if (unlikely(!a->exchange ++ && d_really_is_positive(a->src_dentry) ++ && !d_is_dir(a->src_dentry))) ++ goto out_free; ++ lock_flags |= AuLock_DIRS; ++ } ++ err = aufs_read_and_write_lock2(a->dst_dentry, a->src_dentry, ++ lock_flags); ++ if (unlikely(err)) ++ goto out_free; ++ ++ err = au_d_hashed_positive(a->src_dentry); ++ if (unlikely(err)) ++ goto out_unlock; ++ err = -ENOENT; ++ if (a->dst_inode) { ++ /* ++ * If it is a dir, VFS unhash it before this ++ * function. It means we cannot rely upon d_unhashed(). ++ */ ++ if (unlikely(!a->dst_inode->i_nlink)) ++ goto out_unlock; ++ if (!au_ftest_ren(a->auren_flags, ISDIR_DST)) { ++ err = au_d_hashed_positive(a->dst_dentry); ++ if (unlikely(err && !a->exchange)) ++ goto out_unlock; ++ } else if (unlikely(IS_DEADDIR(a->dst_inode))) ++ goto out_unlock; ++ } else if (unlikely(d_unhashed(a->dst_dentry))) ++ goto out_unlock; ++ ++ /* ++ * is it possible? ++ * yes, it happened (in linux-3.3-rcN) but I don't know why. ++ * there may exist a problem somewhere else. ++ */ ++ err = -EINVAL; ++ if (unlikely(d_inode(a->dst_parent) == d_inode(a->src_dentry))) ++ goto out_unlock; ++ ++ au_fset_ren(a->auren_flags, ISSAMEDIR); /* temporary */ ++ di_write_lock_parent(a->dst_parent); ++ ++ /* which branch we process */ ++ err = au_ren_wbr(a); ++ if (unlikely(err < 0)) ++ goto out_parent; ++ a->br = au_sbr(a->dst_dentry->d_sb, a->btgt); ++ a->h_path.mnt = au_br_mnt(a->br); ++ ++ /* are they available to be renamed */ ++ err = au_ren_may_dir(a); ++ if (unlikely(err)) ++ goto out_children; ++ ++ /* prepare the writable parent dir on the same branch */ ++ if (a->dst_btop == a->btgt) { ++ au_fset_ren(a->auren_flags, WHDST); ++ } else { ++ err = au_cpup_dirs(a->dst_dentry, a->btgt); ++ if (unlikely(err)) ++ goto out_children; ++ } ++ ++ err = 0; ++ if (!a->exchange) { ++ if (a->src_dir != a->dst_dir) { ++ /* ++ * this temporary unlock is safe, ++ * because both dir->i_mutex are locked. ++ */ ++ di_write_unlock(a->dst_parent); ++ di_write_lock_parent(a->src_parent); ++ err = au_wr_dir_need_wh(a->src_dentry, ++ au_ftest_ren(a->auren_flags, ++ ISDIR_SRC), ++ &a->btgt); ++ di_write_unlock(a->src_parent); ++ di_write_lock2_parent(a->src_parent, a->dst_parent, ++ /*isdir*/1); ++ au_fclr_ren(a->auren_flags, ISSAMEDIR); ++ } else ++ err = au_wr_dir_need_wh(a->src_dentry, ++ au_ftest_ren(a->auren_flags, ++ ISDIR_SRC), ++ &a->btgt); ++ } ++ if (unlikely(err < 0)) ++ goto out_children; ++ if (err) ++ au_fset_ren(a->auren_flags, WHSRC); ++ ++ /* cpup src */ ++ if (a->src_btop != a->btgt) { ++ err = au_pin(&pin, a->src_dentry, a->btgt, ++ au_opt_udba(a->src_dentry->d_sb), ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (!err) { ++ struct au_cp_generic cpg = { ++ .dentry = a->src_dentry, ++ .bdst = a->btgt, ++ .bsrc = a->src_btop, ++ .len = -1, ++ .pin = &pin, ++ .flags = AuCpup_DTIME | AuCpup_HOPEN ++ }; ++ AuDebugOn(au_dbtop(a->src_dentry) != a->src_btop); ++ err = au_sio_cpup_simple(&cpg); ++ au_unpin(&pin); ++ } ++ if (unlikely(err)) ++ goto out_children; ++ a->src_btop = a->btgt; ++ a->src_h_dentry = au_h_dptr(a->src_dentry, a->btgt); ++ if (!a->exchange) ++ au_fset_ren(a->auren_flags, WHSRC); ++ } ++ ++ /* cpup dst */ ++ if (a->exchange && a->dst_inode ++ && a->dst_btop != a->btgt) { ++ err = au_pin(&pin, a->dst_dentry, a->btgt, ++ au_opt_udba(a->dst_dentry->d_sb), ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (!err) { ++ struct au_cp_generic cpg = { ++ .dentry = a->dst_dentry, ++ .bdst = a->btgt, ++ .bsrc = a->dst_btop, ++ .len = -1, ++ .pin = &pin, ++ .flags = AuCpup_DTIME | AuCpup_HOPEN ++ }; ++ err = au_sio_cpup_simple(&cpg); ++ au_unpin(&pin); ++ } ++ if (unlikely(err)) ++ goto out_children; ++ a->dst_btop = a->btgt; ++ a->dst_h_dentry = au_h_dptr(a->dst_dentry, a->btgt); ++ } ++ ++ /* lock them all */ ++ err = au_ren_lock(a); ++ if (unlikely(err)) ++ /* leave the copied-up one */ ++ goto out_children; ++ ++ if (!a->exchange) { ++ if (!au_opt_test(au_mntflags(a->dst_dir->i_sb), UDBA_NONE)) ++ err = au_may_ren(a); ++ else if (unlikely(a->dst_dentry->d_name.len > AUFS_MAX_NAMELEN)) ++ err = -ENAMETOOLONG; ++ if (unlikely(err)) ++ goto out_hdir; ++ } ++ ++ /* store timestamps to be revertible */ ++ au_ren_dt(a); ++ ++ /* store dirren info */ ++ if (au_ftest_ren(a->auren_flags, DIRREN)) { ++ err = au_dr_rename(a->src_dentry, a->btgt, ++ &a->dst_dentry->d_name, &rev); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ goto out_dt; ++ } ++ ++ /* here we go */ ++ err = do_rename(a); ++ if (unlikely(err)) ++ goto out_dirren; ++ ++ if (au_ftest_ren(a->auren_flags, DIRREN)) ++ au_dr_rename_fin(a->src_dentry, a->btgt, rev); ++ ++ /* update dir attributes */ ++ au_ren_refresh_dir(a); ++ ++ /* dput/iput all lower dentries */ ++ au_ren_refresh(a); ++ ++ goto out_hdir; /* success */ ++ ++out_dirren: ++ if (au_ftest_ren(a->auren_flags, DIRREN)) ++ au_dr_rename_rev(a->src_dentry, a->btgt, rev); ++out_dt: ++ au_ren_rev_dt(err, a); ++out_hdir: ++ au_ren_unlock(a); ++out_children: ++ au_nhash_wh_free(&a->whlist); ++ if (err && a->dst_inode && a->dst_btop != a->btgt) { ++ AuDbg("btop %d, btgt %d\n", a->dst_btop, a->btgt); ++ au_set_h_dptr(a->dst_dentry, a->btgt, NULL); ++ au_set_dbtop(a->dst_dentry, a->dst_btop); ++ } ++out_parent: ++ if (!err) { ++ if (d_unhashed(a->src_dentry)) ++ au_fset_ren(a->auren_flags, DROPPED_SRC); ++ if (d_unhashed(a->dst_dentry)) ++ au_fset_ren(a->auren_flags, DROPPED_DST); ++ if (!a->exchange) ++ d_move(a->src_dentry, a->dst_dentry); ++ else { ++ d_exchange(a->src_dentry, a->dst_dentry); ++ if (au_ftest_ren(a->auren_flags, DROPPED_DST)) ++ d_drop(a->dst_dentry); ++ } ++ if (au_ftest_ren(a->auren_flags, DROPPED_SRC)) ++ d_drop(a->src_dentry); ++ } else { ++ au_update_dbtop(a->dst_dentry); ++ if (!a->dst_inode) ++ d_drop(a->dst_dentry); ++ } ++ if (au_ftest_ren(a->auren_flags, ISSAMEDIR)) ++ di_write_unlock(a->dst_parent); ++ else ++ di_write_unlock2(a->src_parent, a->dst_parent); ++out_unlock: ++ aufs_read_and_write_unlock2(a->dst_dentry, a->src_dentry); ++out_free: ++ iput(a->dst_inode); ++ if (a->thargs) ++ au_whtmp_rmdir_free(a->thargs); ++ au_kfree_rcu(a); ++out: ++ AuTraceErr(err); ++ return err; ++} +diff --git a/fs/aufs/iinfo.c b/fs/aufs/iinfo.c +new file mode 100644 +index 000000000000..5a837d7d0a33 +--- /dev/null ++++ b/fs/aufs/iinfo.c +@@ -0,0 +1,273 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * inode private data ++ */ ++ ++#include "aufs.h" ++ ++struct inode *au_h_iptr(struct inode *inode, aufs_bindex_t bindex) ++{ ++ struct inode *h_inode; ++ struct au_hinode *hinode; ++ ++ IiMustAnyLock(inode); ++ ++ hinode = au_hinode(au_ii(inode), bindex); ++ h_inode = hinode->hi_inode; ++ AuDebugOn(h_inode && atomic_read(&h_inode->i_count) <= 0); ++ return h_inode; ++} ++ ++/* todo: hard/soft set? */ ++void au_hiput(struct au_hinode *hinode) ++{ ++ au_hn_free(hinode); ++ dput(hinode->hi_whdentry); ++ iput(hinode->hi_inode); ++} ++ ++unsigned int au_hi_flags(struct inode *inode, int isdir) ++{ ++ unsigned int flags; ++ const unsigned int mnt_flags = au_mntflags(inode->i_sb); ++ ++ flags = 0; ++ if (au_opt_test(mnt_flags, XINO)) ++ au_fset_hi(flags, XINO); ++ if (isdir && au_opt_test(mnt_flags, UDBA_HNOTIFY)) ++ au_fset_hi(flags, HNOTIFY); ++ return flags; ++} ++ ++void au_set_h_iptr(struct inode *inode, aufs_bindex_t bindex, ++ struct inode *h_inode, unsigned int flags) ++{ ++ struct au_hinode *hinode; ++ struct inode *hi; ++ struct au_iinfo *iinfo = au_ii(inode); ++ ++ IiMustWriteLock(inode); ++ ++ hinode = au_hinode(iinfo, bindex); ++ hi = hinode->hi_inode; ++ AuDebugOn(h_inode && atomic_read(&h_inode->i_count) <= 0); ++ ++ if (hi) ++ au_hiput(hinode); ++ hinode->hi_inode = h_inode; ++ if (h_inode) { ++ int err; ++ struct super_block *sb = inode->i_sb; ++ struct au_branch *br; ++ ++ AuDebugOn(inode->i_mode ++ && (h_inode->i_mode & S_IFMT) ++ != (inode->i_mode & S_IFMT)); ++ if (bindex == iinfo->ii_btop) ++ au_cpup_igen(inode, h_inode); ++ br = au_sbr(sb, bindex); ++ hinode->hi_id = br->br_id; ++ if (au_ftest_hi(flags, XINO)) { ++ err = au_xino_write(sb, bindex, h_inode->i_ino, ++ inode->i_ino); ++ if (unlikely(err)) ++ AuIOErr1("failed au_xino_write() %d\n", err); ++ } ++ ++ if (au_ftest_hi(flags, HNOTIFY) ++ && au_br_hnotifyable(br->br_perm)) { ++ err = au_hn_alloc(hinode, inode); ++ if (unlikely(err)) ++ AuIOErr1("au_hn_alloc() %d\n", err); ++ } ++ } ++} ++ ++void au_set_hi_wh(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_wh) ++{ ++ struct au_hinode *hinode; ++ ++ IiMustWriteLock(inode); ++ ++ hinode = au_hinode(au_ii(inode), bindex); ++ AuDebugOn(hinode->hi_whdentry); ++ hinode->hi_whdentry = h_wh; ++} ++ ++void au_update_iigen(struct inode *inode, int half) ++{ ++ struct au_iinfo *iinfo; ++ struct au_iigen *iigen; ++ unsigned int sigen; ++ ++ sigen = au_sigen(inode->i_sb); ++ iinfo = au_ii(inode); ++ iigen = &iinfo->ii_generation; ++ spin_lock(&iigen->ig_spin); ++ iigen->ig_generation = sigen; ++ if (half) ++ au_ig_fset(iigen->ig_flags, HALF_REFRESHED); ++ else ++ au_ig_fclr(iigen->ig_flags, HALF_REFRESHED); ++ spin_unlock(&iigen->ig_spin); ++} ++ ++/* it may be called at remount time, too */ ++void au_update_ibrange(struct inode *inode, int do_put_zero) ++{ ++ struct au_iinfo *iinfo; ++ aufs_bindex_t bindex, bbot; ++ ++ AuDebugOn(au_is_bad_inode(inode)); ++ IiMustWriteLock(inode); ++ ++ iinfo = au_ii(inode); ++ if (do_put_zero && iinfo->ii_btop >= 0) { ++ for (bindex = iinfo->ii_btop; bindex <= iinfo->ii_bbot; ++ bindex++) { ++ struct inode *h_i; ++ ++ h_i = au_hinode(iinfo, bindex)->hi_inode; ++ if (h_i ++ && !h_i->i_nlink ++ && !(h_i->i_state & I_LINKABLE)) ++ au_set_h_iptr(inode, bindex, NULL, 0); ++ } ++ } ++ ++ iinfo->ii_btop = -1; ++ iinfo->ii_bbot = -1; ++ bbot = au_sbbot(inode->i_sb); ++ for (bindex = 0; bindex <= bbot; bindex++) ++ if (au_hinode(iinfo, bindex)->hi_inode) { ++ iinfo->ii_btop = bindex; ++ break; ++ } ++ if (iinfo->ii_btop >= 0) ++ for (bindex = bbot; bindex >= iinfo->ii_btop; bindex--) ++ if (au_hinode(iinfo, bindex)->hi_inode) { ++ iinfo->ii_bbot = bindex; ++ break; ++ } ++ AuDebugOn(iinfo->ii_btop > iinfo->ii_bbot); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_icntnr_init_once(void *_c) ++{ ++ struct au_icntnr *c = _c; ++ struct au_iinfo *iinfo = &c->iinfo; ++ ++ spin_lock_init(&iinfo->ii_generation.ig_spin); ++ au_rw_init(&iinfo->ii_rwsem); ++ inode_init_once(&c->vfs_inode); ++} ++ ++void au_hinode_init(struct au_hinode *hinode) ++{ ++ hinode->hi_inode = NULL; ++ hinode->hi_id = -1; ++ au_hn_init(hinode); ++ hinode->hi_whdentry = NULL; ++} ++ ++int au_iinfo_init(struct inode *inode) ++{ ++ struct au_iinfo *iinfo; ++ struct super_block *sb; ++ struct au_hinode *hi; ++ int nbr, i; ++ ++ sb = inode->i_sb; ++ iinfo = &(container_of(inode, struct au_icntnr, vfs_inode)->iinfo); ++ nbr = au_sbbot(sb) + 1; ++ if (unlikely(nbr <= 0)) ++ nbr = 1; ++ hi = kmalloc_array(nbr, sizeof(*iinfo->ii_hinode), GFP_NOFS); ++ if (hi) { ++ au_lcnt_inc(&au_sbi(sb)->si_ninodes); ++ ++ iinfo->ii_hinode = hi; ++ for (i = 0; i < nbr; i++, hi++) ++ au_hinode_init(hi); ++ ++ iinfo->ii_generation.ig_generation = au_sigen(sb); ++ iinfo->ii_btop = -1; ++ iinfo->ii_bbot = -1; ++ iinfo->ii_vdir = NULL; ++ return 0; ++ } ++ return -ENOMEM; ++} ++ ++int au_hinode_realloc(struct au_iinfo *iinfo, int nbr, int may_shrink) ++{ ++ int err, i; ++ struct au_hinode *hip; ++ ++ AuRwMustWriteLock(&iinfo->ii_rwsem); ++ ++ err = -ENOMEM; ++ hip = au_krealloc(iinfo->ii_hinode, sizeof(*hip) * nbr, GFP_NOFS, ++ may_shrink); ++ if (hip) { ++ iinfo->ii_hinode = hip; ++ i = iinfo->ii_bbot + 1; ++ hip += i; ++ for (; i < nbr; i++, hip++) ++ au_hinode_init(hip); ++ err = 0; ++ } ++ ++ return err; ++} ++ ++void au_iinfo_fin(struct inode *inode) ++{ ++ struct au_iinfo *iinfo; ++ struct au_hinode *hi; ++ struct super_block *sb; ++ aufs_bindex_t bindex, bbot; ++ const unsigned char unlinked = !inode->i_nlink; ++ ++ AuDebugOn(au_is_bad_inode(inode)); ++ ++ sb = inode->i_sb; ++ au_lcnt_dec(&au_sbi(sb)->si_ninodes); ++ if (si_pid_test(sb)) ++ au_xino_delete_inode(inode, unlinked); ++ else { ++ /* ++ * it is safe to hide the dependency between sbinfo and ++ * sb->s_umount. ++ */ ++ lockdep_off(); ++ si_noflush_read_lock(sb); ++ au_xino_delete_inode(inode, unlinked); ++ si_read_unlock(sb); ++ lockdep_on(); ++ } ++ ++ iinfo = au_ii(inode); ++ if (iinfo->ii_vdir) ++ au_vdir_free(iinfo->ii_vdir); ++ ++ bindex = iinfo->ii_btop; ++ if (bindex >= 0) { ++ hi = au_hinode(iinfo, bindex); ++ bbot = iinfo->ii_bbot; ++ while (bindex++ <= bbot) { ++ if (hi->hi_inode) ++ au_hiput(hi); ++ hi++; ++ } ++ } ++ au_kfree_rcu(iinfo->ii_hinode); ++ AuRwDestroy(&iinfo->ii_rwsem); ++} +diff --git a/fs/aufs/inode.c b/fs/aufs/inode.c +new file mode 100644 +index 000000000000..c071e525f499 +--- /dev/null ++++ b/fs/aufs/inode.c +@@ -0,0 +1,516 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * inode functions ++ */ ++ ++#include ++#include "aufs.h" ++ ++struct inode *au_igrab(struct inode *inode) ++{ ++ if (inode) { ++ AuDebugOn(!atomic_read(&inode->i_count)); ++ ihold(inode); ++ } ++ return inode; ++} ++ ++static void au_refresh_hinode_attr(struct inode *inode, int do_version) ++{ ++ au_cpup_attr_all(inode, /*force*/0); ++ au_update_iigen(inode, /*half*/1); ++ if (do_version) ++ inode_inc_iversion(inode); ++} ++ ++static int au_ii_refresh(struct inode *inode, int *update) ++{ ++ int err, e, nbr; ++ umode_t type; ++ aufs_bindex_t bindex, new_bindex; ++ struct super_block *sb; ++ struct au_iinfo *iinfo; ++ struct au_hinode *p, *q, tmp; ++ ++ AuDebugOn(au_is_bad_inode(inode)); ++ IiMustWriteLock(inode); ++ ++ *update = 0; ++ sb = inode->i_sb; ++ nbr = au_sbbot(sb) + 1; ++ type = inode->i_mode & S_IFMT; ++ iinfo = au_ii(inode); ++ err = au_hinode_realloc(iinfo, nbr, /*may_shrink*/0); ++ if (unlikely(err)) ++ goto out; ++ ++ AuDebugOn(iinfo->ii_btop < 0); ++ p = au_hinode(iinfo, iinfo->ii_btop); ++ for (bindex = iinfo->ii_btop; bindex <= iinfo->ii_bbot; ++ bindex++, p++) { ++ if (!p->hi_inode) ++ continue; ++ ++ AuDebugOn(type != (p->hi_inode->i_mode & S_IFMT)); ++ new_bindex = au_br_index(sb, p->hi_id); ++ if (new_bindex == bindex) ++ continue; ++ ++ if (new_bindex < 0) { ++ *update = 1; ++ au_hiput(p); ++ p->hi_inode = NULL; ++ continue; ++ } ++ ++ if (new_bindex < iinfo->ii_btop) ++ iinfo->ii_btop = new_bindex; ++ if (iinfo->ii_bbot < new_bindex) ++ iinfo->ii_bbot = new_bindex; ++ /* swap two lower inode, and loop again */ ++ q = au_hinode(iinfo, new_bindex); ++ tmp = *q; ++ *q = *p; ++ *p = tmp; ++ if (tmp.hi_inode) { ++ bindex--; ++ p--; ++ } ++ } ++ au_update_ibrange(inode, /*do_put_zero*/0); ++ au_hinode_realloc(iinfo, nbr, /*may_shrink*/1); /* harmless if err */ ++ e = au_dy_irefresh(inode); ++ if (unlikely(e && !err)) ++ err = e; ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_refresh_iop(struct inode *inode, int force_getattr) ++{ ++ int type; ++ struct au_sbinfo *sbi = au_sbi(inode->i_sb); ++ const struct inode_operations *iop ++ = force_getattr ? aufs_iop : sbi->si_iop_array; ++ ++ if (inode->i_op == iop) ++ return; ++ ++ switch (inode->i_mode & S_IFMT) { ++ case S_IFDIR: ++ type = AuIop_DIR; ++ break; ++ case S_IFLNK: ++ type = AuIop_SYMLINK; ++ break; ++ default: ++ type = AuIop_OTHER; ++ break; ++ } ++ ++ inode->i_op = iop + type; ++ /* unnecessary smp_wmb() */ ++} ++ ++int au_refresh_hinode_self(struct inode *inode) ++{ ++ int err, update; ++ ++ err = au_ii_refresh(inode, &update); ++ if (!err) ++ au_refresh_hinode_attr(inode, update && S_ISDIR(inode->i_mode)); ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_refresh_hinode(struct inode *inode, struct dentry *dentry) ++{ ++ int err, e, update; ++ unsigned int flags; ++ umode_t mode; ++ aufs_bindex_t bindex, bbot; ++ unsigned char isdir; ++ struct au_hinode *p; ++ struct au_iinfo *iinfo; ++ ++ err = au_ii_refresh(inode, &update); ++ if (unlikely(err)) ++ goto out; ++ ++ update = 0; ++ iinfo = au_ii(inode); ++ p = au_hinode(iinfo, iinfo->ii_btop); ++ mode = (inode->i_mode & S_IFMT); ++ isdir = S_ISDIR(mode); ++ flags = au_hi_flags(inode, isdir); ++ bbot = au_dbbot(dentry); ++ for (bindex = au_dbtop(dentry); bindex <= bbot; bindex++) { ++ struct inode *h_i, *h_inode; ++ struct dentry *h_d; ++ ++ h_d = au_h_dptr(dentry, bindex); ++ if (!h_d || d_is_negative(h_d)) ++ continue; ++ ++ h_inode = d_inode(h_d); ++ AuDebugOn(mode != (h_inode->i_mode & S_IFMT)); ++ if (iinfo->ii_btop <= bindex && bindex <= iinfo->ii_bbot) { ++ h_i = au_h_iptr(inode, bindex); ++ if (h_i) { ++ if (h_i == h_inode) ++ continue; ++ err = -EIO; ++ break; ++ } ++ } ++ if (bindex < iinfo->ii_btop) ++ iinfo->ii_btop = bindex; ++ if (iinfo->ii_bbot < bindex) ++ iinfo->ii_bbot = bindex; ++ au_set_h_iptr(inode, bindex, au_igrab(h_inode), flags); ++ update = 1; ++ } ++ au_update_ibrange(inode, /*do_put_zero*/0); ++ e = au_dy_irefresh(inode); ++ if (unlikely(e && !err)) ++ err = e; ++ if (!err) ++ au_refresh_hinode_attr(inode, update && isdir); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int set_inode(struct inode *inode, struct dentry *dentry) ++{ ++ int err; ++ unsigned int flags; ++ umode_t mode; ++ aufs_bindex_t bindex, btop, btail; ++ unsigned char isdir; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ struct au_iinfo *iinfo; ++ const struct inode_operations *iop; ++ ++ IiMustWriteLock(inode); ++ ++ err = 0; ++ isdir = 0; ++ iop = au_sbi(inode->i_sb)->si_iop_array; ++ btop = au_dbtop(dentry); ++ h_dentry = au_h_dptr(dentry, btop); ++ h_inode = d_inode(h_dentry); ++ mode = h_inode->i_mode; ++ switch (mode & S_IFMT) { ++ case S_IFREG: ++ btail = au_dbtail(dentry); ++ inode->i_op = iop + AuIop_OTHER; ++ inode->i_fop = &aufs_file_fop; ++ err = au_dy_iaop(inode, btop, h_inode); ++ if (unlikely(err)) ++ goto out; ++ break; ++ case S_IFDIR: ++ isdir = 1; ++ btail = au_dbtaildir(dentry); ++ inode->i_op = iop + AuIop_DIR; ++ inode->i_fop = &aufs_dir_fop; ++ break; ++ case S_IFLNK: ++ btail = au_dbtail(dentry); ++ inode->i_op = iop + AuIop_SYMLINK; ++ break; ++ case S_IFBLK: ++ case S_IFCHR: ++ case S_IFIFO: ++ case S_IFSOCK: ++ btail = au_dbtail(dentry); ++ inode->i_op = iop + AuIop_OTHER; ++ init_special_inode(inode, mode, h_inode->i_rdev); ++ break; ++ default: ++ AuIOErr("Unknown file type 0%o\n", mode); ++ err = -EIO; ++ goto out; ++ } ++ ++ /* do not set hnotify for whiteouted dirs (SHWH mode) */ ++ flags = au_hi_flags(inode, isdir); ++ if (au_opt_test(au_mntflags(dentry->d_sb), SHWH) ++ && au_ftest_hi(flags, HNOTIFY) ++ && dentry->d_name.len > AUFS_WH_PFX_LEN ++ && !memcmp(dentry->d_name.name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) ++ au_fclr_hi(flags, HNOTIFY); ++ iinfo = au_ii(inode); ++ iinfo->ii_btop = btop; ++ iinfo->ii_bbot = btail; ++ for (bindex = btop; bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry) ++ au_set_h_iptr(inode, bindex, ++ au_igrab(d_inode(h_dentry)), flags); ++ } ++ au_cpup_attr_all(inode, /*force*/1); ++ /* ++ * to force calling aufs_get_acl() every time, ++ * do not call cache_no_acl() for aufs inode. ++ */ ++ ++out: ++ return err; ++} ++ ++/* ++ * successful returns with iinfo write_locked ++ * minus: errno ++ * zero: success, matched ++ * plus: no error, but unmatched ++ */ ++static int reval_inode(struct inode *inode, struct dentry *dentry) ++{ ++ int err; ++ unsigned int gen, igflags; ++ aufs_bindex_t bindex, bbot; ++ struct inode *h_inode, *h_dinode; ++ struct dentry *h_dentry; ++ ++ /* ++ * before this function, if aufs got any iinfo lock, it must be only ++ * one, the parent dir. ++ * it can happen by UDBA and the obsoleted inode number. ++ */ ++ err = -EIO; ++ if (unlikely(inode->i_ino == parent_ino(dentry))) ++ goto out; ++ ++ err = 1; ++ ii_write_lock_new_child(inode); ++ h_dentry = au_h_dptr(dentry, au_dbtop(dentry)); ++ h_dinode = d_inode(h_dentry); ++ bbot = au_ibbot(inode); ++ for (bindex = au_ibtop(inode); bindex <= bbot; bindex++) { ++ h_inode = au_h_iptr(inode, bindex); ++ if (!h_inode || h_inode != h_dinode) ++ continue; ++ ++ err = 0; ++ gen = au_iigen(inode, &igflags); ++ if (gen == au_digen(dentry) ++ && !au_ig_ftest(igflags, HALF_REFRESHED)) ++ break; ++ ++ /* fully refresh inode using dentry */ ++ err = au_refresh_hinode(inode, dentry); ++ if (!err) ++ au_update_iigen(inode, /*half*/0); ++ break; ++ } ++ ++ if (unlikely(err)) ++ ii_write_unlock(inode); ++out: ++ return err; ++} ++ ++int au_ino(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ unsigned int d_type, ino_t *ino) ++{ ++ int err, idx; ++ const int isnondir = d_type != DT_DIR; ++ ++ /* prevent hardlinked inode number from race condition */ ++ if (isnondir) { ++ err = au_xinondir_enter(sb, bindex, h_ino, &idx); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ err = au_xino_read(sb, bindex, h_ino, ino); ++ if (unlikely(err)) ++ goto out_xinondir; ++ ++ if (!*ino) { ++ err = -EIO; ++ *ino = au_xino_new_ino(sb); ++ if (unlikely(!*ino)) ++ goto out_xinondir; ++ err = au_xino_write(sb, bindex, h_ino, *ino); ++ if (unlikely(err)) ++ goto out_xinondir; ++ } ++ ++out_xinondir: ++ if (isnondir && idx >= 0) ++ au_xinondir_leave(sb, bindex, h_ino, idx); ++out: ++ return err; ++} ++ ++/* successful returns with iinfo write_locked */ ++/* todo: return with unlocked? */ ++struct inode *au_new_inode(struct dentry *dentry, int must_new) ++{ ++ struct inode *inode, *h_inode; ++ struct dentry *h_dentry; ++ struct super_block *sb; ++ ino_t h_ino, ino; ++ int err, idx, hlinked; ++ aufs_bindex_t btop; ++ ++ sb = dentry->d_sb; ++ btop = au_dbtop(dentry); ++ h_dentry = au_h_dptr(dentry, btop); ++ h_inode = d_inode(h_dentry); ++ h_ino = h_inode->i_ino; ++ hlinked = !d_is_dir(h_dentry) && h_inode->i_nlink > 1; ++ ++new_ino: ++ /* ++ * stop 'race'-ing between hardlinks under different ++ * parents. ++ */ ++ if (hlinked) { ++ err = au_xinondir_enter(sb, btop, h_ino, &idx); ++ inode = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ err = au_xino_read(sb, btop, h_ino, &ino); ++ inode = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_xinondir; ++ ++ if (!ino) { ++ ino = au_xino_new_ino(sb); ++ if (unlikely(!ino)) { ++ inode = ERR_PTR(-EIO); ++ goto out_xinondir; ++ } ++ } ++ ++ AuDbg("i%lu\n", (unsigned long)ino); ++ inode = au_iget_locked(sb, ino); ++ err = PTR_ERR(inode); ++ if (IS_ERR(inode)) ++ goto out_xinondir; ++ ++ AuDbg("%lx, new %d\n", inode->i_state, !!(inode->i_state & I_NEW)); ++ if (inode->i_state & I_NEW) { ++ ii_write_lock_new_child(inode); ++ err = set_inode(inode, dentry); ++ if (!err) { ++ unlock_new_inode(inode); ++ goto out_xinondir; /* success */ ++ } ++ ++ /* ++ * iget_failed() calls iput(), but we need to call ++ * ii_write_unlock() after iget_failed(). so dirty hack for ++ * i_count. ++ */ ++ atomic_inc(&inode->i_count); ++ iget_failed(inode); ++ ii_write_unlock(inode); ++ au_xino_write(sb, btop, h_ino, /*ino*/0); ++ /* ignore this error */ ++ goto out_iput; ++ } else if (!must_new && !IS_DEADDIR(inode) && inode->i_nlink) { ++ /* ++ * horrible race condition between lookup, readdir and copyup ++ * (or something). ++ */ ++ if (hlinked && idx >= 0) ++ au_xinondir_leave(sb, btop, h_ino, idx); ++ err = reval_inode(inode, dentry); ++ if (unlikely(err < 0)) { ++ hlinked = 0; ++ goto out_iput; ++ } ++ if (!err) ++ goto out; /* success */ ++ else if (hlinked && idx >= 0) { ++ err = au_xinondir_enter(sb, btop, h_ino, &idx); ++ if (unlikely(err)) { ++ iput(inode); ++ inode = ERR_PTR(err); ++ goto out; ++ } ++ } ++ } ++ ++ if (unlikely(au_test_fs_unique_ino(h_inode))) ++ AuWarn1("Warning: Un-notified UDBA or repeatedly renamed dir," ++ " b%d, %s, %pd, hi%lu, i%lu.\n", ++ btop, au_sbtype(h_dentry->d_sb), dentry, ++ (unsigned long)h_ino, (unsigned long)ino); ++ ino = 0; ++ err = au_xino_write(sb, btop, h_ino, /*ino*/0); ++ if (!err) { ++ iput(inode); ++ if (hlinked && idx >= 0) ++ au_xinondir_leave(sb, btop, h_ino, idx); ++ goto new_ino; ++ } ++ ++out_iput: ++ iput(inode); ++ inode = ERR_PTR(err); ++out_xinondir: ++ if (hlinked && idx >= 0) ++ au_xinondir_leave(sb, btop, h_ino, idx); ++out: ++ return inode; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_test_ro(struct super_block *sb, aufs_bindex_t bindex, ++ struct inode *inode) ++{ ++ int err; ++ struct inode *hi; ++ ++ err = au_br_rdonly(au_sbr(sb, bindex)); ++ ++ /* pseudo-link after flushed may happen out of bounds */ ++ if (!err ++ && inode ++ && au_ibtop(inode) <= bindex ++ && bindex <= au_ibbot(inode)) { ++ /* ++ * permission check is unnecessary since vfsub routine ++ * will be called later ++ */ ++ hi = au_h_iptr(inode, bindex); ++ if (hi) ++ err = IS_IMMUTABLE(hi) ? -EROFS : 0; ++ } ++ ++ return err; ++} ++ ++int au_test_h_perm(struct inode *h_inode, int mask) ++{ ++ if (uid_eq(current_fsuid(), GLOBAL_ROOT_UID)) ++ return 0; ++ return inode_permission(h_inode, mask); ++} ++ ++int au_test_h_perm_sio(struct inode *h_inode, int mask) ++{ ++ if (au_test_nfs(h_inode->i_sb) ++ && (mask & MAY_WRITE) ++ && S_ISDIR(h_inode->i_mode)) ++ mask |= MAY_READ; /* force permission check */ ++ return au_test_h_perm(h_inode, mask); ++} +diff --git a/fs/aufs/inode.h b/fs/aufs/inode.h +new file mode 100644 +index 000000000000..833d2ce64e81 +--- /dev/null ++++ b/fs/aufs/inode.h +@@ -0,0 +1,685 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * inode operations ++ */ ++ ++#ifndef __AUFS_INODE_H__ ++#define __AUFS_INODE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include "rwsem.h" ++ ++struct vfsmount; ++ ++struct au_hnotify { ++#ifdef CONFIG_AUFS_HNOTIFY ++#ifdef CONFIG_AUFS_HFSNOTIFY ++ /* never use fsnotify_add_vfsmount_mark() */ ++ struct fsnotify_mark hn_mark; ++#endif ++ struct inode *hn_aufs_inode; /* no get/put */ ++ struct rcu_head rcu; ++#endif ++} ____cacheline_aligned_in_smp; ++ ++struct au_hinode { ++ struct inode *hi_inode; ++ aufs_bindex_t hi_id; ++#ifdef CONFIG_AUFS_HNOTIFY ++ struct au_hnotify *hi_notify; ++#endif ++ ++ /* reference to the copied-up whiteout with get/put */ ++ struct dentry *hi_whdentry; ++}; ++ ++/* ig_flags */ ++#define AuIG_HALF_REFRESHED 1 ++#define au_ig_ftest(flags, name) ((flags) & AuIG_##name) ++#define au_ig_fset(flags, name) \ ++ do { (flags) |= AuIG_##name; } while (0) ++#define au_ig_fclr(flags, name) \ ++ do { (flags) &= ~AuIG_##name; } while (0) ++ ++struct au_iigen { ++ spinlock_t ig_spin; ++ __u32 ig_generation, ig_flags; ++}; ++ ++struct au_vdir; ++struct au_iinfo { ++ struct au_iigen ii_generation; ++ struct super_block *ii_hsb1; /* no get/put */ ++ ++ struct au_rwsem ii_rwsem; ++ aufs_bindex_t ii_btop, ii_bbot; ++ __u32 ii_higen; ++ struct au_hinode *ii_hinode; ++ struct au_vdir *ii_vdir; ++}; ++ ++struct au_icntnr { ++ struct au_iinfo iinfo; ++ struct inode vfs_inode; ++ struct hlist_bl_node plink; ++ struct rcu_head rcu; ++} ____cacheline_aligned_in_smp; ++ ++/* au_pin flags */ ++#define AuPin_DI_LOCKED 1 ++#define AuPin_MNT_WRITE (1 << 1) ++#define au_ftest_pin(flags, name) ((flags) & AuPin_##name) ++#define au_fset_pin(flags, name) \ ++ do { (flags) |= AuPin_##name; } while (0) ++#define au_fclr_pin(flags, name) \ ++ do { (flags) &= ~AuPin_##name; } while (0) ++ ++struct au_pin { ++ /* input */ ++ struct dentry *dentry; ++ unsigned int udba; ++ unsigned char lsc_di, lsc_hi, flags; ++ aufs_bindex_t bindex; ++ ++ /* output */ ++ struct dentry *parent; ++ struct au_hinode *hdir; ++ struct vfsmount *h_mnt; ++ ++ /* temporary unlock/relock for copyup */ ++ struct dentry *h_dentry, *h_parent; ++ struct au_branch *br; ++ struct task_struct *task; ++}; ++ ++void au_pin_hdir_unlock(struct au_pin *p); ++int au_pin_hdir_lock(struct au_pin *p); ++int au_pin_hdir_relock(struct au_pin *p); ++void au_pin_hdir_acquire_nest(struct au_pin *p); ++void au_pin_hdir_release(struct au_pin *p); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_iinfo *au_ii(struct inode *inode) ++{ ++ BUG_ON(is_bad_inode(inode)); ++ return &(container_of(inode, struct au_icntnr, vfs_inode)->iinfo); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* inode.c */ ++struct inode *au_igrab(struct inode *inode); ++void au_refresh_iop(struct inode *inode, int force_getattr); ++int au_refresh_hinode_self(struct inode *inode); ++int au_refresh_hinode(struct inode *inode, struct dentry *dentry); ++int au_ino(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ unsigned int d_type, ino_t *ino); ++struct inode *au_new_inode(struct dentry *dentry, int must_new); ++int au_test_ro(struct super_block *sb, aufs_bindex_t bindex, ++ struct inode *inode); ++int au_test_h_perm(struct inode *h_inode, int mask); ++int au_test_h_perm_sio(struct inode *h_inode, int mask); ++ ++static inline int au_wh_ino(struct super_block *sb, aufs_bindex_t bindex, ++ ino_t h_ino, unsigned int d_type, ino_t *ino) ++{ ++#ifdef CONFIG_AUFS_SHWH ++ return au_ino(sb, bindex, h_ino, d_type, ino); ++#else ++ return 0; ++#endif ++} ++ ++/* i_op.c */ ++enum { ++ AuIop_SYMLINK, ++ AuIop_DIR, ++ AuIop_OTHER, ++ AuIop_Last ++}; ++extern struct inode_operations aufs_iop[AuIop_Last], /* not const */ ++ aufs_iop_nogetattr[AuIop_Last]; ++ ++/* au_wr_dir flags */ ++#define AuWrDir_ADD_ENTRY 1 ++#define AuWrDir_ISDIR (1 << 1) ++#define AuWrDir_TMPFILE (1 << 2) ++#define au_ftest_wrdir(flags, name) ((flags) & AuWrDir_##name) ++#define au_fset_wrdir(flags, name) \ ++ do { (flags) |= AuWrDir_##name; } while (0) ++#define au_fclr_wrdir(flags, name) \ ++ do { (flags) &= ~AuWrDir_##name; } while (0) ++ ++struct au_wr_dir_args { ++ aufs_bindex_t force_btgt; ++ unsigned char flags; ++}; ++int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry, ++ struct au_wr_dir_args *args); ++ ++struct dentry *au_pinned_h_parent(struct au_pin *pin); ++void au_pin_init(struct au_pin *pin, struct dentry *dentry, ++ aufs_bindex_t bindex, int lsc_di, int lsc_hi, ++ unsigned int udba, unsigned char flags); ++int au_pin(struct au_pin *pin, struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int udba, unsigned char flags) __must_check; ++int au_do_pin(struct au_pin *pin) __must_check; ++void au_unpin(struct au_pin *pin); ++int au_reval_for_attr(struct dentry *dentry, unsigned int sigen); ++ ++#define AuIcpup_DID_CPUP 1 ++#define au_ftest_icpup(flags, name) ((flags) & AuIcpup_##name) ++#define au_fset_icpup(flags, name) \ ++ do { (flags) |= AuIcpup_##name; } while (0) ++#define au_fclr_icpup(flags, name) \ ++ do { (flags) &= ~AuIcpup_##name; } while (0) ++ ++struct au_icpup_args { ++ unsigned char flags; ++ unsigned char pin_flags; ++ aufs_bindex_t btgt; ++ unsigned int udba; ++ struct au_pin pin; ++ struct path h_path; ++ struct inode *h_inode; ++}; ++ ++int au_pin_and_icpup(struct dentry *dentry, struct iattr *ia, ++ struct au_icpup_args *a); ++ ++int au_h_path_getattr(struct dentry *dentry, struct inode *inode, int force, ++ struct path *h_path, int locked); ++ ++/* i_op_add.c */ ++int au_may_add(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir); ++int aufs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, ++ dev_t dev); ++int aufs_symlink(struct inode *dir, struct dentry *dentry, const char *symname); ++int aufs_create(struct inode *dir, struct dentry *dentry, umode_t mode, ++ bool want_excl); ++struct vfsub_aopen_args; ++int au_aopen_or_create(struct inode *dir, struct dentry *dentry, ++ struct vfsub_aopen_args *args); ++int aufs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode); ++int aufs_link(struct dentry *src_dentry, struct inode *dir, ++ struct dentry *dentry); ++int aufs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode); ++ ++/* i_op_del.c */ ++int au_wr_dir_need_wh(struct dentry *dentry, int isdir, aufs_bindex_t *bcpup); ++int au_may_del(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir); ++int aufs_unlink(struct inode *dir, struct dentry *dentry); ++int aufs_rmdir(struct inode *dir, struct dentry *dentry); ++ ++/* i_op_ren.c */ ++int au_wbr(struct dentry *dentry, aufs_bindex_t btgt); ++int aufs_rename(struct inode *src_dir, struct dentry *src_dentry, ++ struct inode *dir, struct dentry *dentry, ++ unsigned int flags); ++ ++/* iinfo.c */ ++struct inode *au_h_iptr(struct inode *inode, aufs_bindex_t bindex); ++void au_hiput(struct au_hinode *hinode); ++void au_set_hi_wh(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_wh); ++unsigned int au_hi_flags(struct inode *inode, int isdir); ++ ++/* hinode flags */ ++#define AuHi_XINO 1 ++#define AuHi_HNOTIFY (1 << 1) ++#define au_ftest_hi(flags, name) ((flags) & AuHi_##name) ++#define au_fset_hi(flags, name) \ ++ do { (flags) |= AuHi_##name; } while (0) ++#define au_fclr_hi(flags, name) \ ++ do { (flags) &= ~AuHi_##name; } while (0) ++ ++#ifndef CONFIG_AUFS_HNOTIFY ++#undef AuHi_HNOTIFY ++#define AuHi_HNOTIFY 0 ++#endif ++ ++void au_set_h_iptr(struct inode *inode, aufs_bindex_t bindex, ++ struct inode *h_inode, unsigned int flags); ++ ++void au_update_iigen(struct inode *inode, int half); ++void au_update_ibrange(struct inode *inode, int do_put_zero); ++ ++void au_icntnr_init_once(void *_c); ++void au_hinode_init(struct au_hinode *hinode); ++int au_iinfo_init(struct inode *inode); ++void au_iinfo_fin(struct inode *inode); ++int au_hinode_realloc(struct au_iinfo *iinfo, int nbr, int may_shrink); ++ ++#ifdef CONFIG_PROC_FS ++/* plink.c */ ++int au_plink_maint(struct super_block *sb, int flags); ++struct au_sbinfo; ++void au_plink_maint_leave(struct au_sbinfo *sbinfo); ++int au_plink_maint_enter(struct super_block *sb); ++#ifdef CONFIG_AUFS_DEBUG ++void au_plink_list(struct super_block *sb); ++#else ++AuStubVoid(au_plink_list, struct super_block *sb) ++#endif ++int au_plink_test(struct inode *inode); ++struct dentry *au_plink_lkup(struct inode *inode, aufs_bindex_t bindex); ++void au_plink_append(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_dentry); ++void au_plink_put(struct super_block *sb, int verbose); ++void au_plink_clean(struct super_block *sb, int verbose); ++void au_plink_half_refresh(struct super_block *sb, aufs_bindex_t br_id); ++#else ++AuStubInt0(au_plink_maint, struct super_block *sb, int flags); ++AuStubVoid(au_plink_maint_leave, struct au_sbinfo *sbinfo); ++AuStubInt0(au_plink_maint_enter, struct super_block *sb); ++AuStubVoid(au_plink_list, struct super_block *sb); ++AuStubInt0(au_plink_test, struct inode *inode); ++AuStub(struct dentry *, au_plink_lkup, return NULL, ++ struct inode *inode, aufs_bindex_t bindex); ++AuStubVoid(au_plink_append, struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_dentry); ++AuStubVoid(au_plink_put, struct super_block *sb, int verbose); ++AuStubVoid(au_plink_clean, struct super_block *sb, int verbose); ++AuStubVoid(au_plink_half_refresh, struct super_block *sb, aufs_bindex_t br_id); ++#endif /* CONFIG_PROC_FS */ ++ ++#ifdef CONFIG_AUFS_XATTR ++/* xattr.c */ ++int au_cpup_xattr(struct dentry *h_dst, struct dentry *h_src, int ignore_flags, ++ unsigned int verbose); ++ssize_t aufs_listxattr(struct dentry *dentry, char *list, size_t size); ++void au_xattr_init(struct super_block *sb); ++#else ++AuStubInt0(au_cpup_xattr, struct dentry *h_dst, struct dentry *h_src, ++ int ignore_flags, unsigned int verbose); ++AuStubVoid(au_xattr_init, struct super_block *sb); ++#endif ++ ++#ifdef CONFIG_FS_POSIX_ACL ++struct posix_acl *aufs_get_acl(struct inode *inode, int type); ++int aufs_set_acl(struct inode *inode, struct posix_acl *acl, int type); ++#endif ++ ++#if IS_ENABLED(CONFIG_AUFS_XATTR) || IS_ENABLED(CONFIG_FS_POSIX_ACL) ++enum { ++ AU_XATTR_SET, ++ AU_ACL_SET ++}; ++ ++struct au_sxattr { ++ int type; ++ union { ++ struct { ++ const char *name; ++ const void *value; ++ size_t size; ++ int flags; ++ } set; ++ struct { ++ struct posix_acl *acl; ++ int type; ++ } acl_set; ++ } u; ++}; ++ssize_t au_sxattr(struct dentry *dentry, struct inode *inode, ++ struct au_sxattr *arg); ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock subclass for iinfo */ ++enum { ++ AuLsc_II_CHILD, /* child first */ ++ AuLsc_II_CHILD2, /* rename(2), link(2), and cpup at hnotify */ ++ AuLsc_II_CHILD3, /* copyup dirs */ ++ AuLsc_II_PARENT, /* see AuLsc_I_PARENT in vfsub.h */ ++ AuLsc_II_PARENT2, ++ AuLsc_II_PARENT3, /* copyup dirs */ ++ AuLsc_II_NEW_CHILD ++}; ++ ++/* ++ * ii_read_lock_child, ii_write_lock_child, ++ * ii_read_lock_child2, ii_write_lock_child2, ++ * ii_read_lock_child3, ii_write_lock_child3, ++ * ii_read_lock_parent, ii_write_lock_parent, ++ * ii_read_lock_parent2, ii_write_lock_parent2, ++ * ii_read_lock_parent3, ii_write_lock_parent3, ++ * ii_read_lock_new_child, ii_write_lock_new_child, ++ */ ++#define AuReadLockFunc(name, lsc) \ ++static inline void ii_read_lock_##name(struct inode *i) \ ++{ \ ++ au_rw_read_lock_nested(&au_ii(i)->ii_rwsem, AuLsc_II_##lsc); \ ++} ++ ++#define AuWriteLockFunc(name, lsc) \ ++static inline void ii_write_lock_##name(struct inode *i) \ ++{ \ ++ au_rw_write_lock_nested(&au_ii(i)->ii_rwsem, AuLsc_II_##lsc); \ ++} ++ ++#define AuRWLockFuncs(name, lsc) \ ++ AuReadLockFunc(name, lsc) \ ++ AuWriteLockFunc(name, lsc) ++ ++AuRWLockFuncs(child, CHILD); ++AuRWLockFuncs(child2, CHILD2); ++AuRWLockFuncs(child3, CHILD3); ++AuRWLockFuncs(parent, PARENT); ++AuRWLockFuncs(parent2, PARENT2); ++AuRWLockFuncs(parent3, PARENT3); ++AuRWLockFuncs(new_child, NEW_CHILD); ++ ++#undef AuReadLockFunc ++#undef AuWriteLockFunc ++#undef AuRWLockFuncs ++ ++#define ii_read_unlock(i) au_rw_read_unlock(&au_ii(i)->ii_rwsem) ++#define ii_write_unlock(i) au_rw_write_unlock(&au_ii(i)->ii_rwsem) ++#define ii_downgrade_lock(i) au_rw_dgrade_lock(&au_ii(i)->ii_rwsem) ++ ++#define IiMustNoWaiters(i) AuRwMustNoWaiters(&au_ii(i)->ii_rwsem) ++#define IiMustAnyLock(i) AuRwMustAnyLock(&au_ii(i)->ii_rwsem) ++#define IiMustWriteLock(i) AuRwMustWriteLock(&au_ii(i)->ii_rwsem) ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline void au_icntnr_init(struct au_icntnr *c) ++{ ++#ifdef CONFIG_AUFS_DEBUG ++ c->vfs_inode.i_mode = 0; ++#endif ++} ++ ++static inline unsigned int au_iigen(struct inode *inode, unsigned int *igflags) ++{ ++ unsigned int gen; ++ struct au_iinfo *iinfo; ++ struct au_iigen *iigen; ++ ++ iinfo = au_ii(inode); ++ iigen = &iinfo->ii_generation; ++ spin_lock(&iigen->ig_spin); ++ if (igflags) ++ *igflags = iigen->ig_flags; ++ gen = iigen->ig_generation; ++ spin_unlock(&iigen->ig_spin); ++ ++ return gen; ++} ++ ++/* tiny test for inode number */ ++/* tmpfs generation is too rough */ ++static inline int au_test_higen(struct inode *inode, struct inode *h_inode) ++{ ++ struct au_iinfo *iinfo; ++ ++ iinfo = au_ii(inode); ++ AuRwMustAnyLock(&iinfo->ii_rwsem); ++ return !(iinfo->ii_hsb1 == h_inode->i_sb ++ && iinfo->ii_higen == h_inode->i_generation); ++} ++ ++static inline void au_iigen_dec(struct inode *inode) ++{ ++ struct au_iinfo *iinfo; ++ struct au_iigen *iigen; ++ ++ iinfo = au_ii(inode); ++ iigen = &iinfo->ii_generation; ++ spin_lock(&iigen->ig_spin); ++ iigen->ig_generation--; ++ spin_unlock(&iigen->ig_spin); ++} ++ ++static inline int au_iigen_test(struct inode *inode, unsigned int sigen) ++{ ++ int err; ++ ++ err = 0; ++ if (unlikely(inode && au_iigen(inode, NULL) != sigen)) ++ err = -EIO; ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_hinode *au_hinode(struct au_iinfo *iinfo, ++ aufs_bindex_t bindex) ++{ ++ return iinfo->ii_hinode + bindex; ++} ++ ++static inline int au_is_bad_inode(struct inode *inode) ++{ ++ return !!(is_bad_inode(inode) || !au_hinode(au_ii(inode), 0)); ++} ++ ++static inline aufs_bindex_t au_ii_br_id(struct inode *inode, ++ aufs_bindex_t bindex) ++{ ++ IiMustAnyLock(inode); ++ return au_hinode(au_ii(inode), bindex)->hi_id; ++} ++ ++static inline aufs_bindex_t au_ibtop(struct inode *inode) ++{ ++ IiMustAnyLock(inode); ++ return au_ii(inode)->ii_btop; ++} ++ ++static inline aufs_bindex_t au_ibbot(struct inode *inode) ++{ ++ IiMustAnyLock(inode); ++ return au_ii(inode)->ii_bbot; ++} ++ ++static inline struct au_vdir *au_ivdir(struct inode *inode) ++{ ++ IiMustAnyLock(inode); ++ return au_ii(inode)->ii_vdir; ++} ++ ++static inline struct dentry *au_hi_wh(struct inode *inode, aufs_bindex_t bindex) ++{ ++ IiMustAnyLock(inode); ++ return au_hinode(au_ii(inode), bindex)->hi_whdentry; ++} ++ ++static inline void au_set_ibtop(struct inode *inode, aufs_bindex_t bindex) ++{ ++ IiMustWriteLock(inode); ++ au_ii(inode)->ii_btop = bindex; ++} ++ ++static inline void au_set_ibbot(struct inode *inode, aufs_bindex_t bindex) ++{ ++ IiMustWriteLock(inode); ++ au_ii(inode)->ii_bbot = bindex; ++} ++ ++static inline void au_set_ivdir(struct inode *inode, struct au_vdir *vdir) ++{ ++ IiMustWriteLock(inode); ++ au_ii(inode)->ii_vdir = vdir; ++} ++ ++static inline struct au_hinode *au_hi(struct inode *inode, aufs_bindex_t bindex) ++{ ++ IiMustAnyLock(inode); ++ return au_hinode(au_ii(inode), bindex); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct dentry *au_pinned_parent(struct au_pin *pin) ++{ ++ if (pin) ++ return pin->parent; ++ return NULL; ++} ++ ++static inline struct inode *au_pinned_h_dir(struct au_pin *pin) ++{ ++ if (pin && pin->hdir) ++ return pin->hdir->hi_inode; ++ return NULL; ++} ++ ++static inline struct au_hinode *au_pinned_hdir(struct au_pin *pin) ++{ ++ if (pin) ++ return pin->hdir; ++ return NULL; ++} ++ ++static inline void au_pin_set_dentry(struct au_pin *pin, struct dentry *dentry) ++{ ++ if (pin) ++ pin->dentry = dentry; ++} ++ ++static inline void au_pin_set_parent_lflag(struct au_pin *pin, ++ unsigned char lflag) ++{ ++ if (pin) { ++ if (lflag) ++ au_fset_pin(pin->flags, DI_LOCKED); ++ else ++ au_fclr_pin(pin->flags, DI_LOCKED); ++ } ++} ++ ++#if 0 /* reserved */ ++static inline void au_pin_set_parent(struct au_pin *pin, struct dentry *parent) ++{ ++ if (pin) { ++ dput(pin->parent); ++ pin->parent = dget(parent); ++ } ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_branch; ++#ifdef CONFIG_AUFS_HNOTIFY ++struct au_hnotify_op { ++ void (*ctl)(struct au_hinode *hinode, int do_set); ++ int (*alloc)(struct au_hinode *hinode); ++ ++ /* ++ * if it returns true, the the caller should free hinode->hi_notify, ++ * otherwise ->free() frees it. ++ */ ++ int (*free)(struct au_hinode *hinode, ++ struct au_hnotify *hn) __must_check; ++ ++ void (*fin)(void); ++ int (*init)(void); ++ ++ int (*reset_br)(unsigned int udba, struct au_branch *br, int perm); ++ void (*fin_br)(struct au_branch *br); ++ int (*init_br)(struct au_branch *br, int perm); ++}; ++ ++/* hnotify.c */ ++int au_hn_alloc(struct au_hinode *hinode, struct inode *inode); ++void au_hn_free(struct au_hinode *hinode); ++void au_hn_ctl(struct au_hinode *hinode, int do_set); ++void au_hn_reset(struct inode *inode, unsigned int flags); ++int au_hnotify(struct inode *h_dir, struct au_hnotify *hnotify, u32 mask, ++ const struct qstr *h_child_qstr, struct inode *h_child_inode); ++int au_hnotify_reset_br(unsigned int udba, struct au_branch *br, int perm); ++int au_hnotify_init_br(struct au_branch *br, int perm); ++void au_hnotify_fin_br(struct au_branch *br); ++int __init au_hnotify_init(void); ++void au_hnotify_fin(void); ++ ++/* hfsnotify.c */ ++extern const struct au_hnotify_op au_hnotify_op; ++ ++static inline ++void au_hn_init(struct au_hinode *hinode) ++{ ++ hinode->hi_notify = NULL; ++} ++ ++static inline struct au_hnotify *au_hn(struct au_hinode *hinode) ++{ ++ return hinode->hi_notify; ++} ++ ++#else ++AuStub(int, au_hn_alloc, return -EOPNOTSUPP, ++ struct au_hinode *hinode __maybe_unused, ++ struct inode *inode __maybe_unused) ++AuStub(struct au_hnotify *, au_hn, return NULL, struct au_hinode *hinode) ++AuStubVoid(au_hn_free, struct au_hinode *hinode __maybe_unused) ++AuStubVoid(au_hn_ctl, struct au_hinode *hinode __maybe_unused, ++ int do_set __maybe_unused) ++AuStubVoid(au_hn_reset, struct inode *inode __maybe_unused, ++ unsigned int flags __maybe_unused) ++AuStubInt0(au_hnotify_reset_br, unsigned int udba __maybe_unused, ++ struct au_branch *br __maybe_unused, ++ int perm __maybe_unused) ++AuStubInt0(au_hnotify_init_br, struct au_branch *br __maybe_unused, ++ int perm __maybe_unused) ++AuStubVoid(au_hnotify_fin_br, struct au_branch *br __maybe_unused) ++AuStubInt0(__init au_hnotify_init, void) ++AuStubVoid(au_hnotify_fin, void) ++AuStubVoid(au_hn_init, struct au_hinode *hinode __maybe_unused) ++#endif /* CONFIG_AUFS_HNOTIFY */ ++ ++static inline void au_hn_suspend(struct au_hinode *hdir) ++{ ++ au_hn_ctl(hdir, /*do_set*/0); ++} ++ ++static inline void au_hn_resume(struct au_hinode *hdir) ++{ ++ au_hn_ctl(hdir, /*do_set*/1); ++} ++ ++static inline void au_hn_inode_lock(struct au_hinode *hdir) ++{ ++ inode_lock(hdir->hi_inode); ++ au_hn_suspend(hdir); ++} ++ ++static inline void au_hn_inode_lock_nested(struct au_hinode *hdir, ++ unsigned int sc __maybe_unused) ++{ ++ inode_lock_nested(hdir->hi_inode, sc); ++ au_hn_suspend(hdir); ++} ++ ++#if 0 /* unused */ ++#include "vfsub.h" ++static inline void au_hn_inode_lock_shared_nested(struct au_hinode *hdir, ++ unsigned int sc) ++{ ++ inode_lock_shared_nested(hdir->hi_inode, sc); ++ au_hn_suspend(hdir); ++} ++#endif ++ ++static inline void au_hn_inode_unlock(struct au_hinode *hdir) ++{ ++ au_hn_resume(hdir); ++ inode_unlock(hdir->hi_inode); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_INODE_H__ */ +diff --git a/fs/aufs/ioctl.c b/fs/aufs/ioctl.c +new file mode 100644 +index 000000000000..9d0e969217a9 +--- /dev/null ++++ b/fs/aufs/ioctl.c +@@ -0,0 +1,207 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * ioctl ++ * plink-management and readdir in userspace. ++ * assist the pathconf(3) wrapper library. ++ * move-down ++ * File-based Hierarchical Storage Management. ++ */ ++ ++#include ++#include ++#include "aufs.h" ++ ++static int au_wbr_fd(struct path *path, struct aufs_wbr_fd __user *arg) ++{ ++ int err, fd; ++ aufs_bindex_t wbi, bindex, bbot; ++ struct file *h_file; ++ struct super_block *sb; ++ struct dentry *root; ++ struct au_branch *br; ++ struct aufs_wbr_fd wbrfd = { ++ .oflags = au_dir_roflags, ++ .brid = -1 ++ }; ++ const int valid = O_RDONLY | O_NONBLOCK | O_LARGEFILE | O_DIRECTORY ++ | O_NOATIME | O_CLOEXEC; ++ ++ AuDebugOn(wbrfd.oflags & ~valid); ++ ++ if (arg) { ++ err = copy_from_user(&wbrfd, arg, sizeof(wbrfd)); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ goto out; ++ } ++ ++ err = -EINVAL; ++ AuDbg("wbrfd{0%o, %d}\n", wbrfd.oflags, wbrfd.brid); ++ wbrfd.oflags |= au_dir_roflags; ++ AuDbg("0%o\n", wbrfd.oflags); ++ if (unlikely(wbrfd.oflags & ~valid)) ++ goto out; ++ } ++ ++ fd = get_unused_fd_flags(0); ++ err = fd; ++ if (unlikely(fd < 0)) ++ goto out; ++ ++ h_file = ERR_PTR(-EINVAL); ++ wbi = 0; ++ br = NULL; ++ sb = path->dentry->d_sb; ++ root = sb->s_root; ++ aufs_read_lock(root, AuLock_IR); ++ bbot = au_sbbot(sb); ++ if (wbrfd.brid >= 0) { ++ wbi = au_br_index(sb, wbrfd.brid); ++ if (unlikely(wbi < 0 || wbi > bbot)) ++ goto out_unlock; ++ } ++ ++ h_file = ERR_PTR(-ENOENT); ++ br = au_sbr(sb, wbi); ++ if (!au_br_writable(br->br_perm)) { ++ if (arg) ++ goto out_unlock; ++ ++ bindex = wbi + 1; ++ wbi = -1; ++ for (; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_writable(br->br_perm)) { ++ wbi = bindex; ++ br = au_sbr(sb, wbi); ++ break; ++ } ++ } ++ } ++ AuDbg("wbi %d\n", wbi); ++ if (wbi >= 0) ++ h_file = au_h_open(root, wbi, wbrfd.oflags, NULL, ++ /*force_wr*/0); ++ ++out_unlock: ++ aufs_read_unlock(root, AuLock_IR); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out_fd; ++ ++ au_lcnt_dec(&br->br_nfiles); /* cf. au_h_open() */ ++ fd_install(fd, h_file); ++ err = fd; ++ goto out; /* success */ ++ ++out_fd: ++ put_unused_fd(fd); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++long aufs_ioctl_dir(struct file *file, unsigned int cmd, unsigned long arg) ++{ ++ long err; ++ struct dentry *dentry; ++ ++ switch (cmd) { ++ case AUFS_CTL_RDU: ++ case AUFS_CTL_RDU_INO: ++ err = au_rdu_ioctl(file, cmd, arg); ++ break; ++ ++ case AUFS_CTL_WBR_FD: ++ err = au_wbr_fd(&file->f_path, (void __user *)arg); ++ break; ++ ++ case AUFS_CTL_IBUSY: ++ err = au_ibusy_ioctl(file, arg); ++ break; ++ ++ case AUFS_CTL_BRINFO: ++ err = au_brinfo_ioctl(file, arg); ++ break; ++ ++ case AUFS_CTL_FHSM_FD: ++ dentry = file->f_path.dentry; ++ if (IS_ROOT(dentry)) ++ err = au_fhsm_fd(dentry->d_sb, arg); ++ else ++ err = -ENOTTY; ++ break; ++ ++ default: ++ /* do not call the lower */ ++ AuDbg("0x%x\n", cmd); ++ err = -ENOTTY; ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++long aufs_ioctl_nondir(struct file *file, unsigned int cmd, unsigned long arg) ++{ ++ long err; ++ ++ switch (cmd) { ++ case AUFS_CTL_MVDOWN: ++ err = au_mvdown(file->f_path.dentry, (void __user *)arg); ++ break; ++ ++ case AUFS_CTL_WBR_FD: ++ err = au_wbr_fd(&file->f_path, (void __user *)arg); ++ break; ++ ++ default: ++ /* do not call the lower */ ++ AuDbg("0x%x\n", cmd); ++ err = -ENOTTY; ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++#ifdef CONFIG_COMPAT ++long aufs_compat_ioctl_dir(struct file *file, unsigned int cmd, ++ unsigned long arg) ++{ ++ long err; ++ ++ switch (cmd) { ++ case AUFS_CTL_RDU: ++ case AUFS_CTL_RDU_INO: ++ err = au_rdu_compat_ioctl(file, cmd, arg); ++ break; ++ ++ case AUFS_CTL_IBUSY: ++ err = au_ibusy_compat_ioctl(file, arg); ++ break; ++ ++ case AUFS_CTL_BRINFO: ++ err = au_brinfo_compat_ioctl(file, arg); ++ break; ++ ++ default: ++ err = aufs_ioctl_dir(file, cmd, arg); ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++long aufs_compat_ioctl_nondir(struct file *file, unsigned int cmd, ++ unsigned long arg) ++{ ++ return aufs_ioctl_nondir(file, cmd, (unsigned long)compat_ptr(arg)); ++} ++#endif +diff --git a/fs/aufs/lcnt.h b/fs/aufs/lcnt.h +new file mode 100644 +index 000000000000..c7db43d9e260 +--- /dev/null ++++ b/fs/aufs/lcnt.h +@@ -0,0 +1,173 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2018-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * simple long counter wrapper ++ */ ++ ++#ifndef __AUFS_LCNT_H__ ++#define __AUFS_LCNT_H__ ++ ++#ifdef __KERNEL__ ++ ++#include "debug.h" ++ ++#define AuLCntATOMIC 1 ++#define AuLCntPCPUCNT 2 ++/* ++ * why does percpu_refcount require extra synchronize_rcu()s in ++ * au_br_do_free() ++ */ ++#define AuLCntPCPUREF 3 ++ ++/* #define AuLCntChosen AuLCntATOMIC */ ++#define AuLCntChosen AuLCntPCPUCNT ++/* #define AuLCntChosen AuLCntPCPUREF */ ++ ++#if AuLCntChosen == AuLCntATOMIC ++#include ++ ++typedef atomic_long_t au_lcnt_t; ++ ++static inline int au_lcnt_init(au_lcnt_t *cnt, void *release __maybe_unused) ++{ ++ atomic_long_set(cnt, 0); ++ return 0; ++} ++ ++static inline void au_lcnt_wait_for_fin(au_lcnt_t *cnt __maybe_unused) ++{ ++ /* empty */ ++} ++ ++static inline void au_lcnt_fin(au_lcnt_t *cnt __maybe_unused, ++ int do_sync __maybe_unused) ++{ ++ /* empty */ ++} ++ ++static inline void au_lcnt_inc(au_lcnt_t *cnt) ++{ ++ atomic_long_inc(cnt); ++} ++ ++static inline void au_lcnt_dec(au_lcnt_t *cnt) ++{ ++ atomic_long_dec(cnt); ++} ++ ++static inline long au_lcnt_read(au_lcnt_t *cnt, int do_rev __maybe_unused) ++{ ++ return atomic_long_read(cnt); ++} ++#endif ++ ++#if AuLCntChosen == AuLCntPCPUCNT ++#include ++ ++typedef struct percpu_counter au_lcnt_t; ++ ++static inline int au_lcnt_init(au_lcnt_t *cnt, void *release __maybe_unused) ++{ ++ return percpu_counter_init(cnt, 0, GFP_NOFS); ++} ++ ++static inline void au_lcnt_wait_for_fin(au_lcnt_t *cnt __maybe_unused) ++{ ++ /* empty */ ++} ++ ++static inline void au_lcnt_fin(au_lcnt_t *cnt, int do_sync __maybe_unused) ++{ ++ percpu_counter_destroy(cnt); ++} ++ ++static inline void au_lcnt_inc(au_lcnt_t *cnt) ++{ ++ percpu_counter_inc(cnt); ++} ++ ++static inline void au_lcnt_dec(au_lcnt_t *cnt) ++{ ++ percpu_counter_dec(cnt); ++} ++ ++static inline long au_lcnt_read(au_lcnt_t *cnt, int do_rev __maybe_unused) ++{ ++ s64 n; ++ ++ n = percpu_counter_sum(cnt); ++ BUG_ON(n < 0); ++ if (LONG_MAX != LLONG_MAX ++ && n > LONG_MAX) ++ AuWarn1("%s\n", "wrap-around"); ++ ++ return n; ++} ++#endif ++ ++#if AuLCntChosen == AuLCntPCPUREF ++#include ++ ++typedef struct percpu_ref au_lcnt_t; ++ ++static inline int au_lcnt_init(au_lcnt_t *cnt, percpu_ref_func_t *release) ++{ ++ if (!release) ++ release = percpu_ref_exit; ++ return percpu_ref_init(cnt, release, /*percpu mode*/0, GFP_NOFS); ++} ++ ++static inline void au_lcnt_wait_for_fin(au_lcnt_t *cnt __maybe_unused) ++{ ++ synchronize_rcu(); ++} ++ ++static inline void au_lcnt_fin(au_lcnt_t *cnt, int do_sync) ++{ ++ percpu_ref_kill(cnt); ++ if (do_sync) ++ au_lcnt_wait_for_fin(cnt); ++} ++ ++static inline void au_lcnt_inc(au_lcnt_t *cnt) ++{ ++ percpu_ref_get(cnt); ++} ++ ++static inline void au_lcnt_dec(au_lcnt_t *cnt) ++{ ++ percpu_ref_put(cnt); ++} ++ ++/* ++ * avoid calling this func as possible. ++ */ ++static inline long au_lcnt_read(au_lcnt_t *cnt, int do_rev) ++{ ++ long l; ++ ++ percpu_ref_switch_to_atomic_sync(cnt); ++ l = atomic_long_read(&cnt->count); ++ if (do_rev) ++ percpu_ref_switch_to_percpu(cnt); ++ ++ /* percpu_ref is initialized by 1 instead of 0 */ ++ return l - 1; ++} ++#endif ++ ++#ifdef CONFIG_AUFS_DEBUG ++#define AuLCntZero(val) do { \ ++ long l = val; \ ++ if (l) \ ++ AuDbg("%s = %ld\n", #val, l); \ ++} while (0) ++#else ++#define AuLCntZero(val) do {} while (0) ++#endif ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_LCNT_H__ */ +diff --git a/fs/aufs/loop.c b/fs/aufs/loop.c +new file mode 100644 +index 000000000000..a8b63acc6204 +--- /dev/null ++++ b/fs/aufs/loop.c +@@ -0,0 +1,135 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * support for loopback block device as a branch ++ */ ++ ++#include "aufs.h" ++ ++/* added into drivers/block/loop.c */ ++static struct file *(*backing_file_func)(struct super_block *sb); ++ ++/* ++ * test if two lower dentries have overlapping branches. ++ */ ++int au_test_loopback_overlap(struct super_block *sb, struct dentry *h_adding) ++{ ++ struct super_block *h_sb; ++ struct file *backing_file; ++ ++ if (unlikely(!backing_file_func)) { ++ /* don't load "loop" module here */ ++ backing_file_func = symbol_get(loop_backing_file); ++ if (unlikely(!backing_file_func)) ++ /* "loop" module is not loaded */ ++ return 0; ++ } ++ ++ h_sb = h_adding->d_sb; ++ backing_file = backing_file_func(h_sb); ++ if (!backing_file) ++ return 0; ++ ++ h_adding = backing_file->f_path.dentry; ++ /* ++ * h_adding can be local NFS. ++ * in this case aufs cannot detect the loop. ++ */ ++ if (unlikely(h_adding->d_sb == sb)) ++ return 1; ++ return !!au_test_subdir(h_adding, sb->s_root); ++} ++ ++/* true if a kernel thread named 'loop[0-9].*' accesses a file */ ++int au_test_loopback_kthread(void) ++{ ++ int ret; ++ struct task_struct *tsk = current; ++ char c, comm[sizeof(tsk->comm)]; ++ ++ ret = 0; ++ if (tsk->flags & PF_KTHREAD) { ++ get_task_comm(comm, tsk); ++ c = comm[4]; ++ ret = ('0' <= c && c <= '9' ++ && !strncmp(comm, "loop", 4)); ++ } ++ ++ return ret; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define au_warn_loopback_step 16 ++static int au_warn_loopback_nelem = au_warn_loopback_step; ++static unsigned long *au_warn_loopback_array; ++ ++void au_warn_loopback(struct super_block *h_sb) ++{ ++ int i, new_nelem; ++ unsigned long *a, magic; ++ static DEFINE_SPINLOCK(spin); ++ ++ magic = h_sb->s_magic; ++ spin_lock(&spin); ++ a = au_warn_loopback_array; ++ for (i = 0; i < au_warn_loopback_nelem && *a; i++) ++ if (a[i] == magic) { ++ spin_unlock(&spin); ++ return; ++ } ++ ++ /* h_sb is new to us, print it */ ++ if (i < au_warn_loopback_nelem) { ++ a[i] = magic; ++ goto pr; ++ } ++ ++ /* expand the array */ ++ new_nelem = au_warn_loopback_nelem + au_warn_loopback_step; ++ a = au_kzrealloc(au_warn_loopback_array, ++ au_warn_loopback_nelem * sizeof(unsigned long), ++ new_nelem * sizeof(unsigned long), GFP_ATOMIC, ++ /*may_shrink*/0); ++ if (a) { ++ au_warn_loopback_nelem = new_nelem; ++ au_warn_loopback_array = a; ++ a[i] = magic; ++ goto pr; ++ } ++ ++ spin_unlock(&spin); ++ AuWarn1("realloc failed, ignored\n"); ++ return; ++ ++pr: ++ spin_unlock(&spin); ++ pr_warn("you may want to try another patch for loopback file " ++ "on %s(0x%lx) branch\n", au_sbtype(h_sb), magic); ++} ++ ++int au_loopback_init(void) ++{ ++ int err; ++ struct super_block *sb __maybe_unused; ++ ++ BUILD_BUG_ON(sizeof(sb->s_magic) != sizeof(*au_warn_loopback_array)); ++ ++ err = 0; ++ au_warn_loopback_array = kcalloc(au_warn_loopback_step, ++ sizeof(unsigned long), GFP_NOFS); ++ if (unlikely(!au_warn_loopback_array)) ++ err = -ENOMEM; ++ ++ return err; ++} ++ ++void au_loopback_fin(void) ++{ ++ if (backing_file_func) ++ symbol_put(loop_backing_file); ++ au_kfree_try_rcu(au_warn_loopback_array); ++} +diff --git a/fs/aufs/loop.h b/fs/aufs/loop.h +new file mode 100644 +index 000000000000..94f4f80ae33b +--- /dev/null ++++ b/fs/aufs/loop.h +@@ -0,0 +1,42 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * support for loopback mount as a branch ++ */ ++ ++#ifndef __AUFS_LOOP_H__ ++#define __AUFS_LOOP_H__ ++ ++#ifdef __KERNEL__ ++ ++struct dentry; ++struct super_block; ++ ++#ifdef CONFIG_AUFS_BDEV_LOOP ++/* drivers/block/loop.c */ ++struct file *loop_backing_file(struct super_block *sb); ++ ++/* loop.c */ ++int au_test_loopback_overlap(struct super_block *sb, struct dentry *h_adding); ++int au_test_loopback_kthread(void); ++void au_warn_loopback(struct super_block *h_sb); ++ ++int au_loopback_init(void); ++void au_loopback_fin(void); ++#else ++AuStub(struct file *, loop_backing_file, return NULL, struct super_block *sb) ++ ++AuStubInt0(au_test_loopback_overlap, struct super_block *sb, ++ struct dentry *h_adding) ++AuStubInt0(au_test_loopback_kthread, void) ++AuStubVoid(au_warn_loopback, struct super_block *h_sb) ++ ++AuStubInt0(au_loopback_init, void) ++AuStubVoid(au_loopback_fin, void) ++#endif /* BLK_DEV_LOOP */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_LOOP_H__ */ +diff --git a/fs/aufs/magic.mk b/fs/aufs/magic.mk +new file mode 100644 +index 000000000000..7bc9eef3ffec +--- /dev/null ++++ b/fs/aufs/magic.mk +@@ -0,0 +1,31 @@ ++# SPDX-License-Identifier: GPL-2.0 ++ ++# defined in ${srctree}/fs/fuse/inode.c ++# tristate ++ifdef CONFIG_FUSE_FS ++ccflags-y += -DFUSE_SUPER_MAGIC=0x65735546 ++endif ++ ++# defined in ${srctree}/fs/xfs/xfs_sb.h ++# tristate ++ifdef CONFIG_XFS_FS ++ccflags-y += -DXFS_SB_MAGIC=0x58465342 ++endif ++ ++# defined in ${srctree}/fs/configfs/mount.c ++# tristate ++ifdef CONFIG_CONFIGFS_FS ++ccflags-y += -DCONFIGFS_MAGIC=0x62656570 ++endif ++ ++# defined in ${srctree}/fs/ubifs/ubifs.h ++# tristate ++ifdef CONFIG_UBIFS_FS ++ccflags-y += -DUBIFS_SUPER_MAGIC=0x24051905 ++endif ++ ++# defined in ${srctree}/fs/hfsplus/hfsplus_raw.h ++# tristate ++ifdef CONFIG_HFSPLUS_FS ++ccflags-y += -DHFSPLUS_SUPER_MAGIC=0x482b ++endif +diff --git a/fs/aufs/module.c b/fs/aufs/module.c +new file mode 100644 +index 000000000000..18039801580f +--- /dev/null ++++ b/fs/aufs/module.c +@@ -0,0 +1,259 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * module global variables and operations ++ */ ++ ++#include ++#include ++#include "aufs.h" ++ ++/* shrinkable realloc */ ++void *au_krealloc(void *p, unsigned int new_sz, gfp_t gfp, int may_shrink) ++{ ++ size_t sz; ++ int diff; ++ ++ sz = 0; ++ diff = -1; ++ if (p) { ++#if 0 /* unused */ ++ if (!new_sz) { ++ au_kfree_rcu(p); ++ p = NULL; ++ goto out; ++ } ++#else ++ AuDebugOn(!new_sz); ++#endif ++ sz = ksize(p); ++ diff = au_kmidx_sub(sz, new_sz); ++ } ++ if (sz && !diff) ++ goto out; ++ ++ if (sz < new_sz) ++ /* expand or SLOB */ ++ p = krealloc(p, new_sz, gfp); ++ else if (new_sz < sz && may_shrink) { ++ /* shrink */ ++ void *q; ++ ++ q = kmalloc(new_sz, gfp); ++ if (q) { ++ if (p) { ++ memcpy(q, p, new_sz); ++ au_kfree_try_rcu(p); ++ } ++ p = q; ++ } else ++ p = NULL; ++ } ++ ++out: ++ return p; ++} ++ ++void *au_kzrealloc(void *p, unsigned int nused, unsigned int new_sz, gfp_t gfp, ++ int may_shrink) ++{ ++ p = au_krealloc(p, new_sz, gfp, may_shrink); ++ if (p && new_sz > nused) ++ memset(p + nused, 0, new_sz - nused); ++ return p; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * aufs caches ++ */ ++struct kmem_cache *au_cache[AuCache_Last]; ++ ++static void au_cache_fin(void) ++{ ++ int i; ++ ++ /* ++ * Make sure all delayed rcu free inodes are flushed before we ++ * destroy cache. ++ */ ++ rcu_barrier(); ++ ++ /* excluding AuCache_HNOTIFY */ ++ BUILD_BUG_ON(AuCache_HNOTIFY + 1 != AuCache_Last); ++ for (i = 0; i < AuCache_HNOTIFY; i++) { ++ kmem_cache_destroy(au_cache[i]); ++ au_cache[i] = NULL; ++ } ++} ++ ++static int __init au_cache_init(void) ++{ ++ au_cache[AuCache_DINFO] = AuCacheCtor(au_dinfo, au_di_init_once); ++ if (au_cache[AuCache_DINFO]) ++ /* SLAB_DESTROY_BY_RCU */ ++ au_cache[AuCache_ICNTNR] = AuCacheCtor(au_icntnr, ++ au_icntnr_init_once); ++ if (au_cache[AuCache_ICNTNR]) ++ au_cache[AuCache_FINFO] = AuCacheCtor(au_finfo, ++ au_fi_init_once); ++ if (au_cache[AuCache_FINFO]) ++ au_cache[AuCache_VDIR] = AuCache(au_vdir); ++ if (au_cache[AuCache_VDIR]) ++ au_cache[AuCache_DEHSTR] = AuCache(au_vdir_dehstr); ++ if (au_cache[AuCache_DEHSTR]) ++ return 0; ++ ++ au_cache_fin(); ++ return -ENOMEM; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_dir_roflags; ++ ++#ifdef CONFIG_AUFS_SBILIST ++/* ++ * iterate_supers_type() doesn't protect us from ++ * remounting (branch management) ++ */ ++struct hlist_bl_head au_sbilist; ++#endif ++ ++/* ++ * functions for module interface. ++ */ ++MODULE_LICENSE("GPL"); ++/* MODULE_LICENSE("GPL v2"); */ ++MODULE_AUTHOR("Junjiro R. Okajima "); ++MODULE_DESCRIPTION(AUFS_NAME ++ " -- Advanced multi layered unification filesystem"); ++MODULE_VERSION(AUFS_VERSION); ++ ++/* this module parameter has no meaning when SYSFS is disabled */ ++int sysaufs_brs = 1; ++MODULE_PARM_DESC(brs, "use /fs/aufs/si_*/brN"); ++module_param_named(brs, sysaufs_brs, int, 0444); ++ ++/* this module parameter has no meaning when USER_NS is disabled */ ++bool au_userns; ++MODULE_PARM_DESC(allow_userns, "allow unprivileged to mount under userns"); ++module_param_named(allow_userns, au_userns, bool, 0444); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static char au_esc_chars[0x20 + 3]; /* 0x01-0x20, backslash, del, and NULL */ ++ ++int au_seq_path(struct seq_file *seq, struct path *path) ++{ ++ int err; ++ ++ err = seq_path(seq, path, au_esc_chars); ++ if (err >= 0) ++ err = 0; ++ else ++ err = -ENOMEM; ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int __init aufs_init(void) ++{ ++ int err, i; ++ char *p; ++ ++ p = au_esc_chars; ++ for (i = 1; i <= ' '; i++) ++ *p++ = i; ++ *p++ = '\\'; ++ *p++ = '\x7f'; ++ *p = 0; ++ ++ au_dir_roflags = au_file_roflags(O_DIRECTORY | O_LARGEFILE); ++ ++ memcpy(aufs_iop_nogetattr, aufs_iop, sizeof(aufs_iop)); ++ for (i = 0; i < AuIop_Last; i++) ++ aufs_iop_nogetattr[i].getattr = NULL; ++ ++ memset(au_cache, 0, sizeof(au_cache)); /* including hnotify */ ++ ++ au_sbilist_init(); ++ sysaufs_brs_init(); ++ au_debug_init(); ++ au_dy_init(); ++ err = sysaufs_init(); ++ if (unlikely(err)) ++ goto out; ++ err = dbgaufs_init(); ++ if (unlikely(err)) ++ goto out_sysaufs; ++ err = au_procfs_init(); ++ if (unlikely(err)) ++ goto out_dbgaufs; ++ err = au_wkq_init(); ++ if (unlikely(err)) ++ goto out_procfs; ++ err = au_loopback_init(); ++ if (unlikely(err)) ++ goto out_wkq; ++ err = au_hnotify_init(); ++ if (unlikely(err)) ++ goto out_loopback; ++ err = au_sysrq_init(); ++ if (unlikely(err)) ++ goto out_hin; ++ err = au_cache_init(); ++ if (unlikely(err)) ++ goto out_sysrq; ++ ++ aufs_fs_type.fs_flags |= au_userns ? FS_USERNS_MOUNT : 0; ++ err = register_filesystem(&aufs_fs_type); ++ if (unlikely(err)) ++ goto out_cache; ++ ++ /* since we define pr_fmt, call printk directly */ ++ printk(KERN_INFO AUFS_NAME " " AUFS_VERSION "\n"); ++ goto out; /* success */ ++ ++out_cache: ++ au_cache_fin(); ++out_sysrq: ++ au_sysrq_fin(); ++out_hin: ++ au_hnotify_fin(); ++out_loopback: ++ au_loopback_fin(); ++out_wkq: ++ au_wkq_fin(); ++out_procfs: ++ au_procfs_fin(); ++out_dbgaufs: ++ dbgaufs_fin(); ++out_sysaufs: ++ sysaufs_fin(); ++ au_dy_fin(); ++out: ++ return err; ++} ++ ++static void __exit aufs_exit(void) ++{ ++ unregister_filesystem(&aufs_fs_type); ++ au_cache_fin(); ++ au_sysrq_fin(); ++ au_hnotify_fin(); ++ au_loopback_fin(); ++ au_wkq_fin(); ++ au_procfs_fin(); ++ dbgaufs_fin(); ++ sysaufs_fin(); ++ au_dy_fin(); ++} ++ ++module_init(aufs_init); ++module_exit(aufs_exit); +diff --git a/fs/aufs/module.h b/fs/aufs/module.h +new file mode 100644 +index 000000000000..cf4679c65542 +--- /dev/null ++++ b/fs/aufs/module.h +@@ -0,0 +1,153 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * module initialization and module-global ++ */ ++ ++#ifndef __AUFS_MODULE_H__ ++#define __AUFS_MODULE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include "debug.h" ++#include "dentry.h" ++#include "dir.h" ++#include "file.h" ++#include "inode.h" ++ ++struct path; ++struct seq_file; ++ ++/* module parameters */ ++extern int sysaufs_brs; ++extern bool au_userns; ++ ++/* ---------------------------------------------------------------------- */ ++ ++extern int au_dir_roflags; ++ ++void *au_krealloc(void *p, unsigned int new_sz, gfp_t gfp, int may_shrink); ++void *au_kzrealloc(void *p, unsigned int nused, unsigned int new_sz, gfp_t gfp, ++ int may_shrink); ++ ++/* ++ * Comparing the size of the object with sizeof(struct rcu_head) ++ * case 1: object is always larger ++ * --> au_kfree_rcu() or au_kfree_do_rcu() ++ * case 2: object is always smaller ++ * --> au_kfree_small() ++ * case 3: object can be any size ++ * --> au_kfree_try_rcu() ++ */ ++ ++static inline void au_kfree_do_rcu(const void *p) ++{ ++ struct { ++ struct rcu_head rcu; ++ } *a = (void *)p; ++ ++ kfree_rcu(a, rcu); ++} ++ ++#define au_kfree_rcu(_p) do { \ ++ typeof(_p) p = (_p); \ ++ BUILD_BUG_ON(sizeof(*p) < sizeof(struct rcu_head)); \ ++ if (p) \ ++ au_kfree_do_rcu(p); \ ++ } while (0) ++ ++#define au_kfree_do_sz_test(sz) (sz >= sizeof(struct rcu_head)) ++#define au_kfree_sz_test(p) (p && au_kfree_do_sz_test(ksize(p))) ++ ++static inline void au_kfree_try_rcu(const void *p) ++{ ++ if (!p) ++ return; ++ if (au_kfree_sz_test(p)) ++ au_kfree_do_rcu(p); ++ else ++ kfree(p); ++} ++ ++static inline void au_kfree_small(const void *p) ++{ ++ if (!p) ++ return; ++ AuDebugOn(au_kfree_sz_test(p)); ++ kfree(p); ++} ++ ++static inline int au_kmidx_sub(size_t sz, size_t new_sz) ++{ ++#ifndef CONFIG_SLOB ++ return kmalloc_index(sz) - kmalloc_index(new_sz); ++#else ++ return -1; /* SLOB is untested */ ++#endif ++} ++ ++int au_seq_path(struct seq_file *seq, struct path *path); ++ ++#ifdef CONFIG_PROC_FS ++/* procfs.c */ ++int __init au_procfs_init(void); ++void au_procfs_fin(void); ++#else ++AuStubInt0(au_procfs_init, void); ++AuStubVoid(au_procfs_fin, void); ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* kmem cache */ ++enum { ++ AuCache_DINFO, ++ AuCache_ICNTNR, ++ AuCache_FINFO, ++ AuCache_VDIR, ++ AuCache_DEHSTR, ++ AuCache_HNOTIFY, /* must be last */ ++ AuCache_Last ++}; ++ ++extern struct kmem_cache *au_cache[AuCache_Last]; ++ ++#define AuCacheFlags (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD) ++#define AuCache(type) KMEM_CACHE(type, AuCacheFlags) ++#define AuCacheCtor(type, ctor) \ ++ kmem_cache_create(#type, sizeof(struct type), \ ++ __alignof__(struct type), AuCacheFlags, ctor) ++ ++#define AuCacheFuncs(name, index) \ ++ static inline struct au_##name *au_cache_alloc_##name(void) \ ++ { return kmem_cache_alloc(au_cache[AuCache_##index], GFP_NOFS); } \ ++ static inline void au_cache_free_##name##_norcu(struct au_##name *p) \ ++ { kmem_cache_free(au_cache[AuCache_##index], p); } \ ++ \ ++ static inline void au_cache_free_##name##_rcu_cb(struct rcu_head *rcu) \ ++ { void *p = rcu; \ ++ p -= offsetof(struct au_##name, rcu); \ ++ kmem_cache_free(au_cache[AuCache_##index], p); } \ ++ static inline void au_cache_free_##name##_rcu(struct au_##name *p) \ ++ { BUILD_BUG_ON(sizeof(struct au_##name) < sizeof(struct rcu_head)); \ ++ call_rcu(&p->rcu, au_cache_free_##name##_rcu_cb); } \ ++ \ ++ static inline void au_cache_free_##name(struct au_##name *p) \ ++ { /* au_cache_free_##name##_norcu(p); */ \ ++ au_cache_free_##name##_rcu(p); } ++ ++AuCacheFuncs(dinfo, DINFO); ++AuCacheFuncs(icntnr, ICNTNR); ++AuCacheFuncs(finfo, FINFO); ++AuCacheFuncs(vdir, VDIR); ++AuCacheFuncs(vdir_dehstr, DEHSTR); ++#ifdef CONFIG_AUFS_HNOTIFY ++AuCacheFuncs(hnotify, HNOTIFY); ++#endif ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_MODULE_H__ */ +diff --git a/fs/aufs/mvdown.c b/fs/aufs/mvdown.c +new file mode 100644 +index 000000000000..d28a33f4a944 +--- /dev/null ++++ b/fs/aufs/mvdown.c +@@ -0,0 +1,693 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2011-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * move-down, opposite of copy-up ++ */ ++ ++#include "aufs.h" ++ ++struct au_mvd_args { ++ struct { ++ struct super_block *h_sb; ++ struct dentry *h_parent; ++ struct au_hinode *hdir; ++ struct inode *h_dir, *h_inode; ++ struct au_pin pin; ++ } info[AUFS_MVDOWN_NARRAY]; ++ ++ struct aufs_mvdown mvdown; ++ struct dentry *dentry, *parent; ++ struct inode *inode, *dir; ++ struct super_block *sb; ++ aufs_bindex_t bopq, bwh, bfound; ++ unsigned char rename_lock; ++}; ++ ++#define mvd_errno mvdown.au_errno ++#define mvd_bsrc mvdown.stbr[AUFS_MVDOWN_UPPER].bindex ++#define mvd_src_brid mvdown.stbr[AUFS_MVDOWN_UPPER].brid ++#define mvd_bdst mvdown.stbr[AUFS_MVDOWN_LOWER].bindex ++#define mvd_dst_brid mvdown.stbr[AUFS_MVDOWN_LOWER].brid ++ ++#define mvd_h_src_sb info[AUFS_MVDOWN_UPPER].h_sb ++#define mvd_h_src_parent info[AUFS_MVDOWN_UPPER].h_parent ++#define mvd_hdir_src info[AUFS_MVDOWN_UPPER].hdir ++#define mvd_h_src_dir info[AUFS_MVDOWN_UPPER].h_dir ++#define mvd_h_src_inode info[AUFS_MVDOWN_UPPER].h_inode ++#define mvd_pin_src info[AUFS_MVDOWN_UPPER].pin ++ ++#define mvd_h_dst_sb info[AUFS_MVDOWN_LOWER].h_sb ++#define mvd_h_dst_parent info[AUFS_MVDOWN_LOWER].h_parent ++#define mvd_hdir_dst info[AUFS_MVDOWN_LOWER].hdir ++#define mvd_h_dst_dir info[AUFS_MVDOWN_LOWER].h_dir ++#define mvd_h_dst_inode info[AUFS_MVDOWN_LOWER].h_inode ++#define mvd_pin_dst info[AUFS_MVDOWN_LOWER].pin ++ ++#define AU_MVD_PR(flag, ...) do { \ ++ if (flag) \ ++ pr_err(__VA_ARGS__); \ ++ } while (0) ++ ++static int find_lower_writable(struct au_mvd_args *a) ++{ ++ struct super_block *sb; ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ ++ sb = a->sb; ++ bindex = a->mvd_bsrc; ++ bbot = au_sbbot(sb); ++ if (a->mvdown.flags & AUFS_MVDOWN_FHSM_LOWER) ++ for (bindex++; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_fhsm(br->br_perm) ++ && !sb_rdonly(au_br_sb(br))) ++ return bindex; ++ } ++ else if (!(a->mvdown.flags & AUFS_MVDOWN_ROLOWER)) ++ for (bindex++; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (!au_br_rdonly(br)) ++ return bindex; ++ } ++ else ++ for (bindex++; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (!sb_rdonly(au_br_sb(br))) { ++ if (au_br_rdonly(br)) ++ a->mvdown.flags ++ |= AUFS_MVDOWN_ROLOWER_R; ++ return bindex; ++ } ++ } ++ ++ return -1; ++} ++ ++/* make the parent dir on bdst */ ++static int au_do_mkdir(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ ++ err = 0; ++ a->mvd_hdir_src = au_hi(a->dir, a->mvd_bsrc); ++ a->mvd_hdir_dst = au_hi(a->dir, a->mvd_bdst); ++ a->mvd_h_src_parent = au_h_dptr(a->parent, a->mvd_bsrc); ++ a->mvd_h_dst_parent = NULL; ++ if (au_dbbot(a->parent) >= a->mvd_bdst) ++ a->mvd_h_dst_parent = au_h_dptr(a->parent, a->mvd_bdst); ++ if (!a->mvd_h_dst_parent) { ++ err = au_cpdown_dirs(a->dentry, a->mvd_bdst); ++ if (unlikely(err)) { ++ AU_MVD_PR(dmsg, "cpdown_dirs failed\n"); ++ goto out; ++ } ++ a->mvd_h_dst_parent = au_h_dptr(a->parent, a->mvd_bdst); ++ } ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* lock them all */ ++static int au_do_lock(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ struct dentry *h_trap; ++ ++ a->mvd_h_src_sb = au_sbr_sb(a->sb, a->mvd_bsrc); ++ a->mvd_h_dst_sb = au_sbr_sb(a->sb, a->mvd_bdst); ++ err = au_pin(&a->mvd_pin_dst, a->dentry, a->mvd_bdst, ++ au_opt_udba(a->sb), ++ AuPin_MNT_WRITE | AuPin_DI_LOCKED); ++ AuTraceErr(err); ++ if (unlikely(err)) { ++ AU_MVD_PR(dmsg, "pin_dst failed\n"); ++ goto out; ++ } ++ ++ if (a->mvd_h_src_sb != a->mvd_h_dst_sb) { ++ a->rename_lock = 0; ++ au_pin_init(&a->mvd_pin_src, a->dentry, a->mvd_bsrc, ++ AuLsc_DI_PARENT, AuLsc_I_PARENT3, ++ au_opt_udba(a->sb), ++ AuPin_MNT_WRITE | AuPin_DI_LOCKED); ++ err = au_do_pin(&a->mvd_pin_src); ++ AuTraceErr(err); ++ a->mvd_h_src_dir = d_inode(a->mvd_h_src_parent); ++ if (unlikely(err)) { ++ AU_MVD_PR(dmsg, "pin_src failed\n"); ++ goto out_dst; ++ } ++ goto out; /* success */ ++ } ++ ++ a->rename_lock = 1; ++ au_pin_hdir_unlock(&a->mvd_pin_dst); ++ err = au_pin(&a->mvd_pin_src, a->dentry, a->mvd_bsrc, ++ au_opt_udba(a->sb), ++ AuPin_MNT_WRITE | AuPin_DI_LOCKED); ++ AuTraceErr(err); ++ a->mvd_h_src_dir = d_inode(a->mvd_h_src_parent); ++ if (unlikely(err)) { ++ AU_MVD_PR(dmsg, "pin_src failed\n"); ++ au_pin_hdir_lock(&a->mvd_pin_dst); ++ goto out_dst; ++ } ++ au_pin_hdir_unlock(&a->mvd_pin_src); ++ h_trap = vfsub_lock_rename(a->mvd_h_src_parent, a->mvd_hdir_src, ++ a->mvd_h_dst_parent, a->mvd_hdir_dst); ++ if (h_trap) { ++ err = (h_trap != a->mvd_h_src_parent); ++ if (err) ++ err = (h_trap != a->mvd_h_dst_parent); ++ } ++ BUG_ON(err); /* it should never happen */ ++ if (unlikely(a->mvd_h_src_dir != au_pinned_h_dir(&a->mvd_pin_src))) { ++ err = -EBUSY; ++ AuTraceErr(err); ++ vfsub_unlock_rename(a->mvd_h_src_parent, a->mvd_hdir_src, ++ a->mvd_h_dst_parent, a->mvd_hdir_dst); ++ au_pin_hdir_lock(&a->mvd_pin_src); ++ au_unpin(&a->mvd_pin_src); ++ au_pin_hdir_lock(&a->mvd_pin_dst); ++ goto out_dst; ++ } ++ goto out; /* success */ ++ ++out_dst: ++ au_unpin(&a->mvd_pin_dst); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static void au_do_unlock(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ if (!a->rename_lock) ++ au_unpin(&a->mvd_pin_src); ++ else { ++ vfsub_unlock_rename(a->mvd_h_src_parent, a->mvd_hdir_src, ++ a->mvd_h_dst_parent, a->mvd_hdir_dst); ++ au_pin_hdir_lock(&a->mvd_pin_src); ++ au_unpin(&a->mvd_pin_src); ++ au_pin_hdir_lock(&a->mvd_pin_dst); ++ } ++ au_unpin(&a->mvd_pin_dst); ++} ++ ++/* copy-down the file */ ++static int au_do_cpdown(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ struct au_cp_generic cpg = { ++ .dentry = a->dentry, ++ .bdst = a->mvd_bdst, ++ .bsrc = a->mvd_bsrc, ++ .len = -1, ++ .pin = &a->mvd_pin_dst, ++ .flags = AuCpup_DTIME | AuCpup_HOPEN ++ }; ++ ++ AuDbg("b%d, b%d\n", cpg.bsrc, cpg.bdst); ++ if (a->mvdown.flags & AUFS_MVDOWN_OWLOWER) ++ au_fset_cpup(cpg.flags, OVERWRITE); ++ if (a->mvdown.flags & AUFS_MVDOWN_ROLOWER) ++ au_fset_cpup(cpg.flags, RWDST); ++ err = au_sio_cpdown_simple(&cpg); ++ if (unlikely(err)) ++ AU_MVD_PR(dmsg, "cpdown failed\n"); ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ++ * unlink the whiteout on bdst if exist which may be created by UDBA while we ++ * were sleeping ++ */ ++static int au_do_unlink_wh(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ struct path h_path; ++ struct au_branch *br; ++ struct inode *delegated; ++ ++ br = au_sbr(a->sb, a->mvd_bdst); ++ h_path.dentry = au_wh_lkup(a->mvd_h_dst_parent, &a->dentry->d_name, br); ++ err = PTR_ERR(h_path.dentry); ++ if (IS_ERR(h_path.dentry)) { ++ AU_MVD_PR(dmsg, "wh_lkup failed\n"); ++ goto out; ++ } ++ ++ err = 0; ++ if (d_is_positive(h_path.dentry)) { ++ h_path.mnt = au_br_mnt(br); ++ delegated = NULL; ++ err = vfsub_unlink(d_inode(a->mvd_h_dst_parent), &h_path, ++ &delegated, /*force*/0); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ if (unlikely(err)) ++ AU_MVD_PR(dmsg, "wh_unlink failed\n"); ++ } ++ dput(h_path.dentry); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ++ * unlink the topmost h_dentry ++ */ ++static int au_do_unlink(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ struct path h_path; ++ struct inode *delegated; ++ ++ h_path.mnt = au_sbr_mnt(a->sb, a->mvd_bsrc); ++ h_path.dentry = au_h_dptr(a->dentry, a->mvd_bsrc); ++ delegated = NULL; ++ err = vfsub_unlink(a->mvd_h_src_dir, &h_path, &delegated, /*force*/0); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ if (unlikely(err)) ++ AU_MVD_PR(dmsg, "unlink failed\n"); ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++/* Since mvdown succeeded, we ignore an error of this function */ ++static void au_do_stfs(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ struct au_branch *br; ++ ++ a->mvdown.flags |= AUFS_MVDOWN_STFS_FAILED; ++ br = au_sbr(a->sb, a->mvd_bsrc); ++ err = au_br_stfs(br, &a->mvdown.stbr[AUFS_MVDOWN_UPPER].stfs); ++ if (!err) { ++ br = au_sbr(a->sb, a->mvd_bdst); ++ a->mvdown.stbr[AUFS_MVDOWN_LOWER].brid = br->br_id; ++ err = au_br_stfs(br, &a->mvdown.stbr[AUFS_MVDOWN_LOWER].stfs); ++ } ++ if (!err) ++ a->mvdown.flags &= ~AUFS_MVDOWN_STFS_FAILED; ++ else ++ AU_MVD_PR(dmsg, "statfs failed (%d), ignored\n", err); ++} ++ ++/* ++ * copy-down the file and unlink the bsrc file. ++ * - unlink the bdst whout if exist ++ * - copy-down the file (with whtmp name and rename) ++ * - unlink the bsrc file ++ */ ++static int au_do_mvdown(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ ++ err = au_do_mkdir(dmsg, a); ++ if (!err) ++ err = au_do_lock(dmsg, a); ++ if (unlikely(err)) ++ goto out; ++ ++ /* ++ * do not revert the activities we made on bdst since they should be ++ * harmless in aufs. ++ */ ++ ++ err = au_do_cpdown(dmsg, a); ++ if (!err) ++ err = au_do_unlink_wh(dmsg, a); ++ if (!err && !(a->mvdown.flags & AUFS_MVDOWN_KUPPER)) ++ err = au_do_unlink(dmsg, a); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ AuDbg("%pd2, 0x%x, %d --> %d\n", ++ a->dentry, a->mvdown.flags, a->mvd_bsrc, a->mvd_bdst); ++ if (find_lower_writable(a) < 0) ++ a->mvdown.flags |= AUFS_MVDOWN_BOTTOM; ++ ++ if (a->mvdown.flags & AUFS_MVDOWN_STFS) ++ au_do_stfs(dmsg, a); ++ ++ /* maintain internal array */ ++ if (!(a->mvdown.flags & AUFS_MVDOWN_KUPPER)) { ++ au_set_h_dptr(a->dentry, a->mvd_bsrc, NULL); ++ au_set_dbtop(a->dentry, a->mvd_bdst); ++ au_set_h_iptr(a->inode, a->mvd_bsrc, NULL, /*flags*/0); ++ au_set_ibtop(a->inode, a->mvd_bdst); ++ } else { ++ /* hide the lower */ ++ au_set_h_dptr(a->dentry, a->mvd_bdst, NULL); ++ au_set_dbbot(a->dentry, a->mvd_bsrc); ++ au_set_h_iptr(a->inode, a->mvd_bdst, NULL, /*flags*/0); ++ au_set_ibbot(a->inode, a->mvd_bsrc); ++ } ++ if (au_dbbot(a->dentry) < a->mvd_bdst) ++ au_set_dbbot(a->dentry, a->mvd_bdst); ++ if (au_ibbot(a->inode) < a->mvd_bdst) ++ au_set_ibbot(a->inode, a->mvd_bdst); ++ ++out_unlock: ++ au_do_unlock(dmsg, a); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* make sure the file is idle */ ++static int au_mvd_args_busy(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err, plinked; ++ ++ err = 0; ++ plinked = !!au_opt_test(au_mntflags(a->sb), PLINK); ++ if (au_dbtop(a->dentry) == a->mvd_bsrc ++ && au_dcount(a->dentry) == 1 ++ && atomic_read(&a->inode->i_count) == 1 ++ /* && a->mvd_h_src_inode->i_nlink == 1 */ ++ && (!plinked || !au_plink_test(a->inode)) ++ && a->inode->i_nlink == 1) ++ goto out; ++ ++ err = -EBUSY; ++ AU_MVD_PR(dmsg, ++ "b%d, d{b%d, c%d?}, i{c%d?, l%u}, hi{l%u}, p{%d, %d}\n", ++ a->mvd_bsrc, au_dbtop(a->dentry), au_dcount(a->dentry), ++ atomic_read(&a->inode->i_count), a->inode->i_nlink, ++ a->mvd_h_src_inode->i_nlink, ++ plinked, plinked ? au_plink_test(a->inode) : 0); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* make sure the parent dir is fine */ ++static int au_mvd_args_parent(const unsigned char dmsg, ++ struct au_mvd_args *a) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ ++ err = 0; ++ if (unlikely(au_alive_dir(a->parent))) { ++ err = -ENOENT; ++ AU_MVD_PR(dmsg, "parent dir is dead\n"); ++ goto out; ++ } ++ ++ a->bopq = au_dbdiropq(a->parent); ++ bindex = au_wbr_nonopq(a->dentry, a->mvd_bdst); ++ AuDbg("b%d\n", bindex); ++ if (unlikely((bindex >= 0 && bindex < a->mvd_bdst) ++ || (a->bopq != -1 && a->bopq < a->mvd_bdst))) { ++ err = -EINVAL; ++ a->mvd_errno = EAU_MVDOWN_OPAQUE; ++ AU_MVD_PR(dmsg, "ancestor is opaque b%d, b%d\n", ++ a->bopq, a->mvd_bdst); ++ } ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_mvd_args_intermediate(const unsigned char dmsg, ++ struct au_mvd_args *a) ++{ ++ int err; ++ struct au_dinfo *dinfo, *tmp; ++ ++ /* lookup the next lower positive entry */ ++ err = -ENOMEM; ++ tmp = au_di_alloc(a->sb, AuLsc_DI_TMP); ++ if (unlikely(!tmp)) ++ goto out; ++ ++ a->bfound = -1; ++ a->bwh = -1; ++ dinfo = au_di(a->dentry); ++ au_di_cp(tmp, dinfo); ++ au_di_swap(tmp, dinfo); ++ ++ /* returns the number of positive dentries */ ++ err = au_lkup_dentry(a->dentry, a->mvd_bsrc + 1, ++ /* AuLkup_IGNORE_PERM */ 0); ++ if (!err) ++ a->bwh = au_dbwh(a->dentry); ++ else if (err > 0) ++ a->bfound = au_dbtop(a->dentry); ++ ++ au_di_swap(tmp, dinfo); ++ au_rw_write_unlock(&tmp->di_rwsem); ++ au_di_free(tmp); ++ if (unlikely(err < 0)) ++ AU_MVD_PR(dmsg, "failed look-up lower\n"); ++ ++ /* ++ * here, we have these cases. ++ * bfound == -1 ++ * no positive dentry under bsrc. there are more sub-cases. ++ * bwh < 0 ++ * there no whiteout, we can safely move-down. ++ * bwh <= bsrc ++ * impossible ++ * bsrc < bwh && bwh < bdst ++ * there is a whiteout on RO branch. cannot proceed. ++ * bwh == bdst ++ * there is a whiteout on the RW target branch. it should ++ * be removed. ++ * bdst < bwh ++ * there is a whiteout somewhere unrelated branch. ++ * -1 < bfound && bfound <= bsrc ++ * impossible. ++ * bfound < bdst ++ * found, but it is on RO branch between bsrc and bdst. cannot ++ * proceed. ++ * bfound == bdst ++ * found, replace it if AUFS_MVDOWN_FORCE is set. otherwise return ++ * error. ++ * bdst < bfound ++ * found, after we create the file on bdst, it will be hidden. ++ */ ++ ++ AuDebugOn(a->bfound == -1 ++ && a->bwh != -1 ++ && a->bwh <= a->mvd_bsrc); ++ AuDebugOn(-1 < a->bfound ++ && a->bfound <= a->mvd_bsrc); ++ ++ err = -EINVAL; ++ if (a->bfound == -1 ++ && a->mvd_bsrc < a->bwh ++ && a->bwh != -1 ++ && a->bwh < a->mvd_bdst) { ++ a->mvd_errno = EAU_MVDOWN_WHITEOUT; ++ AU_MVD_PR(dmsg, "bsrc %d, bdst %d, bfound %d, bwh %d\n", ++ a->mvd_bsrc, a->mvd_bdst, a->bfound, a->bwh); ++ goto out; ++ } else if (a->bfound != -1 && a->bfound < a->mvd_bdst) { ++ a->mvd_errno = EAU_MVDOWN_UPPER; ++ AU_MVD_PR(dmsg, "bdst %d, bfound %d\n", ++ a->mvd_bdst, a->bfound); ++ goto out; ++ } ++ ++ err = 0; /* success */ ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_mvd_args_exist(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ ++ err = 0; ++ if (!(a->mvdown.flags & AUFS_MVDOWN_OWLOWER) ++ && a->bfound == a->mvd_bdst) ++ err = -EEXIST; ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_mvd_args(const unsigned char dmsg, struct au_mvd_args *a) ++{ ++ int err; ++ struct au_branch *br; ++ ++ err = -EISDIR; ++ if (unlikely(S_ISDIR(a->inode->i_mode))) ++ goto out; ++ ++ err = -EINVAL; ++ if (!(a->mvdown.flags & AUFS_MVDOWN_BRID_UPPER)) ++ a->mvd_bsrc = au_ibtop(a->inode); ++ else { ++ a->mvd_bsrc = au_br_index(a->sb, a->mvd_src_brid); ++ if (unlikely(a->mvd_bsrc < 0 ++ || (a->mvd_bsrc < au_dbtop(a->dentry) ++ || au_dbbot(a->dentry) < a->mvd_bsrc ++ || !au_h_dptr(a->dentry, a->mvd_bsrc)) ++ || (a->mvd_bsrc < au_ibtop(a->inode) ++ || au_ibbot(a->inode) < a->mvd_bsrc ++ || !au_h_iptr(a->inode, a->mvd_bsrc)))) { ++ a->mvd_errno = EAU_MVDOWN_NOUPPER; ++ AU_MVD_PR(dmsg, "no upper\n"); ++ goto out; ++ } ++ } ++ if (unlikely(a->mvd_bsrc == au_sbbot(a->sb))) { ++ a->mvd_errno = EAU_MVDOWN_BOTTOM; ++ AU_MVD_PR(dmsg, "on the bottom\n"); ++ goto out; ++ } ++ a->mvd_h_src_inode = au_h_iptr(a->inode, a->mvd_bsrc); ++ br = au_sbr(a->sb, a->mvd_bsrc); ++ err = au_br_rdonly(br); ++ if (!(a->mvdown.flags & AUFS_MVDOWN_ROUPPER)) { ++ if (unlikely(err)) ++ goto out; ++ } else if (!(vfsub_native_ro(a->mvd_h_src_inode) ++ || IS_APPEND(a->mvd_h_src_inode))) { ++ if (err) ++ a->mvdown.flags |= AUFS_MVDOWN_ROUPPER_R; ++ /* go on */ ++ } else ++ goto out; ++ ++ err = -EINVAL; ++ if (!(a->mvdown.flags & AUFS_MVDOWN_BRID_LOWER)) { ++ a->mvd_bdst = find_lower_writable(a); ++ if (unlikely(a->mvd_bdst < 0)) { ++ a->mvd_errno = EAU_MVDOWN_BOTTOM; ++ AU_MVD_PR(dmsg, "no writable lower branch\n"); ++ goto out; ++ } ++ } else { ++ a->mvd_bdst = au_br_index(a->sb, a->mvd_dst_brid); ++ if (unlikely(a->mvd_bdst < 0 ++ || au_sbbot(a->sb) < a->mvd_bdst)) { ++ a->mvd_errno = EAU_MVDOWN_NOLOWERBR; ++ AU_MVD_PR(dmsg, "no lower brid\n"); ++ goto out; ++ } ++ } ++ ++ err = au_mvd_args_busy(dmsg, a); ++ if (!err) ++ err = au_mvd_args_parent(dmsg, a); ++ if (!err) ++ err = au_mvd_args_intermediate(dmsg, a); ++ if (!err) ++ err = au_mvd_args_exist(dmsg, a); ++ if (!err) ++ AuDbg("b%d, b%d\n", a->mvd_bsrc, a->mvd_bdst); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_mvdown(struct dentry *dentry, struct aufs_mvdown __user *uarg) ++{ ++ int err, e; ++ unsigned char dmsg; ++ struct au_mvd_args *args; ++ struct inode *inode; ++ ++ inode = d_inode(dentry); ++ err = -EPERM; ++ if (unlikely(!capable(CAP_SYS_ADMIN))) ++ goto out; ++ ++ err = -ENOMEM; ++ args = kmalloc(sizeof(*args), GFP_NOFS); ++ if (unlikely(!args)) ++ goto out; ++ ++ err = copy_from_user(&args->mvdown, uarg, sizeof(args->mvdown)); ++ if (!err) ++ /* VERIFY_WRITE */ ++ err = !access_ok(uarg, sizeof(*uarg)); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ goto out_free; ++ } ++ AuDbg("flags 0x%x\n", args->mvdown.flags); ++ args->mvdown.flags &= ~(AUFS_MVDOWN_ROLOWER_R | AUFS_MVDOWN_ROUPPER_R); ++ args->mvdown.au_errno = 0; ++ args->dentry = dentry; ++ args->inode = inode; ++ args->sb = dentry->d_sb; ++ ++ err = -ENOENT; ++ dmsg = !!(args->mvdown.flags & AUFS_MVDOWN_DMSG); ++ args->parent = dget_parent(dentry); ++ args->dir = d_inode(args->parent); ++ inode_lock_nested(args->dir, I_MUTEX_PARENT); ++ dput(args->parent); ++ if (unlikely(args->parent != dentry->d_parent)) { ++ AU_MVD_PR(dmsg, "parent dir is moved\n"); ++ goto out_dir; ++ } ++ ++ inode_lock_nested(inode, I_MUTEX_CHILD); ++ err = aufs_read_lock(dentry, AuLock_DW | AuLock_FLUSH | AuLock_NOPLMW); ++ if (unlikely(err)) ++ goto out_inode; ++ ++ di_write_lock_parent(args->parent); ++ err = au_mvd_args(dmsg, args); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ err = au_do_mvdown(dmsg, args); ++ if (unlikely(err)) ++ goto out_parent; ++ ++ au_cpup_attr_timesizes(args->dir); ++ au_cpup_attr_timesizes(inode); ++ if (!(args->mvdown.flags & AUFS_MVDOWN_KUPPER)) ++ au_cpup_igen(inode, au_h_iptr(inode, args->mvd_bdst)); ++ /* au_digen_dec(dentry); */ ++ ++out_parent: ++ di_write_unlock(args->parent); ++ aufs_read_unlock(dentry, AuLock_DW); ++out_inode: ++ inode_unlock(inode); ++out_dir: ++ inode_unlock(args->dir); ++out_free: ++ e = copy_to_user(uarg, &args->mvdown, sizeof(args->mvdown)); ++ if (unlikely(e)) ++ err = -EFAULT; ++ au_kfree_rcu(args); ++out: ++ AuTraceErr(err); ++ return err; ++} +diff --git a/fs/aufs/opts.c b/fs/aufs/opts.c +new file mode 100644 +index 000000000000..7448ed020e38 +--- /dev/null ++++ b/fs/aufs/opts.c +@@ -0,0 +1,1867 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * mount options/flags ++ */ ++ ++#include ++#include /* a distribution requires */ ++#include ++#include "aufs.h" ++ ++/* ---------------------------------------------------------------------- */ ++ ++enum { ++ Opt_br, ++ Opt_add, Opt_del, Opt_mod, Opt_append, Opt_prepend, ++ Opt_idel, Opt_imod, ++ Opt_dirwh, Opt_rdcache, Opt_rdblk, Opt_rdhash, ++ Opt_rdblk_def, Opt_rdhash_def, ++ Opt_xino, Opt_noxino, ++ Opt_trunc_xino, Opt_trunc_xino_v, Opt_notrunc_xino, ++ Opt_trunc_xino_path, Opt_itrunc_xino, ++ Opt_trunc_xib, Opt_notrunc_xib, ++ Opt_shwh, Opt_noshwh, ++ Opt_plink, Opt_noplink, Opt_list_plink, ++ Opt_udba, ++ Opt_dio, Opt_nodio, ++ Opt_diropq_a, Opt_diropq_w, ++ Opt_warn_perm, Opt_nowarn_perm, ++ Opt_wbr_copyup, Opt_wbr_create, ++ Opt_fhsm_sec, ++ Opt_verbose, Opt_noverbose, ++ Opt_sum, Opt_nosum, Opt_wsum, ++ Opt_dirperm1, Opt_nodirperm1, ++ Opt_dirren, Opt_nodirren, ++ Opt_acl, Opt_noacl, ++ Opt_tail, Opt_ignore, Opt_ignore_silent, Opt_err ++}; ++ ++static match_table_t options = { ++ {Opt_br, "br=%s"}, ++ {Opt_br, "br:%s"}, ++ ++ {Opt_add, "add=%d:%s"}, ++ {Opt_add, "add:%d:%s"}, ++ {Opt_add, "ins=%d:%s"}, ++ {Opt_add, "ins:%d:%s"}, ++ {Opt_append, "append=%s"}, ++ {Opt_append, "append:%s"}, ++ {Opt_prepend, "prepend=%s"}, ++ {Opt_prepend, "prepend:%s"}, ++ ++ {Opt_del, "del=%s"}, ++ {Opt_del, "del:%s"}, ++ /* {Opt_idel, "idel:%d"}, */ ++ {Opt_mod, "mod=%s"}, ++ {Opt_mod, "mod:%s"}, ++ /* {Opt_imod, "imod:%d:%s"}, */ ++ ++ {Opt_dirwh, "dirwh=%d"}, ++ ++ {Opt_xino, "xino=%s"}, ++ {Opt_noxino, "noxino"}, ++ {Opt_trunc_xino, "trunc_xino"}, ++ {Opt_trunc_xino_v, "trunc_xino_v=%d:%d"}, ++ {Opt_notrunc_xino, "notrunc_xino"}, ++ {Opt_trunc_xino_path, "trunc_xino=%s"}, ++ {Opt_itrunc_xino, "itrunc_xino=%d"}, ++ /* {Opt_zxino, "zxino=%s"}, */ ++ {Opt_trunc_xib, "trunc_xib"}, ++ {Opt_notrunc_xib, "notrunc_xib"}, ++ ++#ifdef CONFIG_PROC_FS ++ {Opt_plink, "plink"}, ++#else ++ {Opt_ignore_silent, "plink"}, ++#endif ++ ++ {Opt_noplink, "noplink"}, ++ ++#ifdef CONFIG_AUFS_DEBUG ++ {Opt_list_plink, "list_plink"}, ++#endif ++ ++ {Opt_udba, "udba=%s"}, ++ ++ {Opt_dio, "dio"}, ++ {Opt_nodio, "nodio"}, ++ ++#ifdef CONFIG_AUFS_DIRREN ++ {Opt_dirren, "dirren"}, ++ {Opt_nodirren, "nodirren"}, ++#else ++ {Opt_ignore, "dirren"}, ++ {Opt_ignore_silent, "nodirren"}, ++#endif ++ ++#ifdef CONFIG_AUFS_FHSM ++ {Opt_fhsm_sec, "fhsm_sec=%d"}, ++#else ++ {Opt_ignore, "fhsm_sec=%d"}, ++#endif ++ ++ {Opt_diropq_a, "diropq=always"}, ++ {Opt_diropq_a, "diropq=a"}, ++ {Opt_diropq_w, "diropq=whiteouted"}, ++ {Opt_diropq_w, "diropq=w"}, ++ ++ {Opt_warn_perm, "warn_perm"}, ++ {Opt_nowarn_perm, "nowarn_perm"}, ++ ++ /* keep them temporary */ ++ {Opt_ignore_silent, "nodlgt"}, ++ {Opt_ignore, "clean_plink"}, ++ ++#ifdef CONFIG_AUFS_SHWH ++ {Opt_shwh, "shwh"}, ++#endif ++ {Opt_noshwh, "noshwh"}, ++ ++ {Opt_dirperm1, "dirperm1"}, ++ {Opt_nodirperm1, "nodirperm1"}, ++ ++ {Opt_verbose, "verbose"}, ++ {Opt_verbose, "v"}, ++ {Opt_noverbose, "noverbose"}, ++ {Opt_noverbose, "quiet"}, ++ {Opt_noverbose, "q"}, ++ {Opt_noverbose, "silent"}, ++ ++ {Opt_sum, "sum"}, ++ {Opt_nosum, "nosum"}, ++ {Opt_wsum, "wsum"}, ++ ++ {Opt_rdcache, "rdcache=%d"}, ++ {Opt_rdblk, "rdblk=%d"}, ++ {Opt_rdblk_def, "rdblk=def"}, ++ {Opt_rdhash, "rdhash=%d"}, ++ {Opt_rdhash_def, "rdhash=def"}, ++ ++ {Opt_wbr_create, "create=%s"}, ++ {Opt_wbr_create, "create_policy=%s"}, ++ {Opt_wbr_copyup, "cpup=%s"}, ++ {Opt_wbr_copyup, "copyup=%s"}, ++ {Opt_wbr_copyup, "copyup_policy=%s"}, ++ ++ /* generic VFS flag */ ++#ifdef CONFIG_FS_POSIX_ACL ++ {Opt_acl, "acl"}, ++ {Opt_noacl, "noacl"}, ++#else ++ {Opt_ignore, "acl"}, ++ {Opt_ignore_silent, "noacl"}, ++#endif ++ ++ /* internal use for the scripts */ ++ {Opt_ignore_silent, "si=%s"}, ++ ++ {Opt_br, "dirs=%s"}, ++ {Opt_ignore, "debug=%d"}, ++ {Opt_ignore, "delete=whiteout"}, ++ {Opt_ignore, "delete=all"}, ++ {Opt_ignore, "imap=%s"}, ++ ++ /* temporary workaround, due to old mount(8)? */ ++ {Opt_ignore_silent, "relatime"}, ++ ++ {Opt_err, NULL} ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static const char *au_parser_pattern(int val, match_table_t tbl) ++{ ++ struct match_token *p; ++ ++ p = tbl; ++ while (p->pattern) { ++ if (p->token == val) ++ return p->pattern; ++ p++; ++ } ++ BUG(); ++ return "??"; ++} ++ ++static const char *au_optstr(int *val, match_table_t tbl) ++{ ++ struct match_token *p; ++ int v; ++ ++ v = *val; ++ if (!v) ++ goto out; ++ p = tbl; ++ while (p->pattern) { ++ if (p->token ++ && (v & p->token) == p->token) { ++ *val &= ~p->token; ++ return p->pattern; ++ } ++ p++; ++ } ++ ++out: ++ return NULL; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static match_table_t brperm = { ++ {AuBrPerm_RO, AUFS_BRPERM_RO}, ++ {AuBrPerm_RR, AUFS_BRPERM_RR}, ++ {AuBrPerm_RW, AUFS_BRPERM_RW}, ++ {0, NULL} ++}; ++ ++static match_table_t brattr = { ++ /* general */ ++ {AuBrAttr_COO_REG, AUFS_BRATTR_COO_REG}, ++ {AuBrAttr_COO_ALL, AUFS_BRATTR_COO_ALL}, ++ /* 'unpin' attrib is meaningless since linux-3.18-rc1 */ ++ {AuBrAttr_UNPIN, AUFS_BRATTR_UNPIN}, ++#ifdef CONFIG_AUFS_FHSM ++ {AuBrAttr_FHSM, AUFS_BRATTR_FHSM}, ++#endif ++#ifdef CONFIG_AUFS_XATTR ++ {AuBrAttr_ICEX, AUFS_BRATTR_ICEX}, ++ {AuBrAttr_ICEX_SEC, AUFS_BRATTR_ICEX_SEC}, ++ {AuBrAttr_ICEX_SYS, AUFS_BRATTR_ICEX_SYS}, ++ {AuBrAttr_ICEX_TR, AUFS_BRATTR_ICEX_TR}, ++ {AuBrAttr_ICEX_USR, AUFS_BRATTR_ICEX_USR}, ++ {AuBrAttr_ICEX_OTH, AUFS_BRATTR_ICEX_OTH}, ++#endif ++ ++ /* ro/rr branch */ ++ {AuBrRAttr_WH, AUFS_BRRATTR_WH}, ++ ++ /* rw branch */ ++ {AuBrWAttr_MOO, AUFS_BRWATTR_MOO}, ++ {AuBrWAttr_NoLinkWH, AUFS_BRWATTR_NLWH}, ++ ++ {0, NULL} ++}; ++ ++static int br_attr_val(char *str, match_table_t table, substring_t args[]) ++{ ++ int attr, v; ++ char *p; ++ ++ attr = 0; ++ do { ++ p = strchr(str, '+'); ++ if (p) ++ *p = 0; ++ v = match_token(str, table, args); ++ if (v) { ++ if (v & AuBrAttr_CMOO_Mask) ++ attr &= ~AuBrAttr_CMOO_Mask; ++ attr |= v; ++ } else { ++ if (p) ++ *p = '+'; ++ pr_warn("ignored branch attribute %s\n", str); ++ break; ++ } ++ if (p) ++ str = p + 1; ++ } while (p); ++ ++ return attr; ++} ++ ++static int au_do_optstr_br_attr(au_br_perm_str_t *str, int perm) ++{ ++ int sz; ++ const char *p; ++ char *q; ++ ++ q = str->a; ++ *q = 0; ++ p = au_optstr(&perm, brattr); ++ if (p) { ++ sz = strlen(p); ++ memcpy(q, p, sz + 1); ++ q += sz; ++ } else ++ goto out; ++ ++ do { ++ p = au_optstr(&perm, brattr); ++ if (p) { ++ *q++ = '+'; ++ sz = strlen(p); ++ memcpy(q, p, sz + 1); ++ q += sz; ++ } ++ } while (p); ++ ++out: ++ return q - str->a; ++} ++ ++static int noinline_for_stack br_perm_val(char *perm) ++{ ++ int val, bad, sz; ++ char *p; ++ substring_t args[MAX_OPT_ARGS]; ++ au_br_perm_str_t attr; ++ ++ p = strchr(perm, '+'); ++ if (p) ++ *p = 0; ++ val = match_token(perm, brperm, args); ++ if (!val) { ++ if (p) ++ *p = '+'; ++ pr_warn("ignored branch permission %s\n", perm); ++ val = AuBrPerm_RO; ++ goto out; ++ } ++ if (!p) ++ goto out; ++ ++ val |= br_attr_val(p + 1, brattr, args); ++ ++ bad = 0; ++ switch (val & AuBrPerm_Mask) { ++ case AuBrPerm_RO: ++ case AuBrPerm_RR: ++ bad = val & AuBrWAttr_Mask; ++ val &= ~AuBrWAttr_Mask; ++ break; ++ case AuBrPerm_RW: ++ bad = val & AuBrRAttr_Mask; ++ val &= ~AuBrRAttr_Mask; ++ break; ++ } ++ ++ /* ++ * 'unpin' attrib becomes meaningless since linux-3.18-rc1, but aufs ++ * does not treat it as an error, just warning. ++ * this is a tiny guard for the user operation. ++ */ ++ if (val & AuBrAttr_UNPIN) { ++ bad |= AuBrAttr_UNPIN; ++ val &= ~AuBrAttr_UNPIN; ++ } ++ ++ if (unlikely(bad)) { ++ sz = au_do_optstr_br_attr(&attr, bad); ++ AuDebugOn(!sz); ++ pr_warn("ignored branch attribute %s\n", attr.a); ++ } ++ ++out: ++ return val; ++} ++ ++void au_optstr_br_perm(au_br_perm_str_t *str, int perm) ++{ ++ au_br_perm_str_t attr; ++ const char *p; ++ char *q; ++ int sz; ++ ++ q = str->a; ++ p = au_optstr(&perm, brperm); ++ AuDebugOn(!p || !*p); ++ sz = strlen(p); ++ memcpy(q, p, sz + 1); ++ q += sz; ++ ++ sz = au_do_optstr_br_attr(&attr, perm); ++ if (sz) { ++ *q++ = '+'; ++ memcpy(q, attr.a, sz + 1); ++ } ++ ++ AuDebugOn(strlen(str->a) >= sizeof(str->a)); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static match_table_t udbalevel = { ++ {AuOpt_UDBA_REVAL, "reval"}, ++ {AuOpt_UDBA_NONE, "none"}, ++#ifdef CONFIG_AUFS_HNOTIFY ++ {AuOpt_UDBA_HNOTIFY, "notify"}, /* abstraction */ ++#ifdef CONFIG_AUFS_HFSNOTIFY ++ {AuOpt_UDBA_HNOTIFY, "fsnotify"}, ++#endif ++#endif ++ {-1, NULL} ++}; ++ ++static int noinline_for_stack udba_val(char *str) ++{ ++ substring_t args[MAX_OPT_ARGS]; ++ ++ return match_token(str, udbalevel, args); ++} ++ ++const char *au_optstr_udba(int udba) ++{ ++ return au_parser_pattern(udba, udbalevel); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static match_table_t au_wbr_create_policy = { ++ {AuWbrCreate_TDP, "tdp"}, ++ {AuWbrCreate_TDP, "top-down-parent"}, ++ {AuWbrCreate_RR, "rr"}, ++ {AuWbrCreate_RR, "round-robin"}, ++ {AuWbrCreate_MFS, "mfs"}, ++ {AuWbrCreate_MFS, "most-free-space"}, ++ {AuWbrCreate_MFSV, "mfs:%d"}, ++ {AuWbrCreate_MFSV, "most-free-space:%d"}, ++ ++ /* top-down regardless the parent, and then mfs */ ++ {AuWbrCreate_TDMFS, "tdmfs:%d"}, ++ {AuWbrCreate_TDMFSV, "tdmfs:%d:%d"}, ++ ++ {AuWbrCreate_MFSRR, "mfsrr:%d"}, ++ {AuWbrCreate_MFSRRV, "mfsrr:%d:%d"}, ++ {AuWbrCreate_PMFS, "pmfs"}, ++ {AuWbrCreate_PMFSV, "pmfs:%d"}, ++ {AuWbrCreate_PMFSRR, "pmfsrr:%d"}, ++ {AuWbrCreate_PMFSRRV, "pmfsrr:%d:%d"}, ++ ++ {-1, NULL} ++}; ++ ++static int au_wbr_mfs_wmark(substring_t *arg, char *str, ++ struct au_opt_wbr_create *create) ++{ ++ int err; ++ unsigned long long ull; ++ ++ err = 0; ++ if (!match_u64(arg, &ull)) ++ create->mfsrr_watermark = ull; ++ else { ++ pr_err("bad integer in %s\n", str); ++ err = -EINVAL; ++ } ++ ++ return err; ++} ++ ++static int au_wbr_mfs_sec(substring_t *arg, char *str, ++ struct au_opt_wbr_create *create) ++{ ++ int n, err; ++ ++ err = 0; ++ if (!match_int(arg, &n) && 0 <= n && n <= AUFS_MFS_MAX_SEC) ++ create->mfs_second = n; ++ else { ++ pr_err("bad integer in %s\n", str); ++ err = -EINVAL; ++ } ++ ++ return err; ++} ++ ++static int noinline_for_stack ++au_wbr_create_val(char *str, struct au_opt_wbr_create *create) ++{ ++ int err, e; ++ substring_t args[MAX_OPT_ARGS]; ++ ++ err = match_token(str, au_wbr_create_policy, args); ++ create->wbr_create = err; ++ switch (err) { ++ case AuWbrCreate_MFSRRV: ++ case AuWbrCreate_TDMFSV: ++ case AuWbrCreate_PMFSRRV: ++ e = au_wbr_mfs_wmark(&args[0], str, create); ++ if (!e) ++ e = au_wbr_mfs_sec(&args[1], str, create); ++ if (unlikely(e)) ++ err = e; ++ break; ++ case AuWbrCreate_MFSRR: ++ case AuWbrCreate_TDMFS: ++ case AuWbrCreate_PMFSRR: ++ e = au_wbr_mfs_wmark(&args[0], str, create); ++ if (unlikely(e)) { ++ err = e; ++ break; ++ } ++ /*FALLTHROUGH*/ ++ case AuWbrCreate_MFS: ++ case AuWbrCreate_PMFS: ++ create->mfs_second = AUFS_MFS_DEF_SEC; ++ break; ++ case AuWbrCreate_MFSV: ++ case AuWbrCreate_PMFSV: ++ e = au_wbr_mfs_sec(&args[0], str, create); ++ if (unlikely(e)) ++ err = e; ++ break; ++ } ++ ++ return err; ++} ++ ++const char *au_optstr_wbr_create(int wbr_create) ++{ ++ return au_parser_pattern(wbr_create, au_wbr_create_policy); ++} ++ ++static match_table_t au_wbr_copyup_policy = { ++ {AuWbrCopyup_TDP, "tdp"}, ++ {AuWbrCopyup_TDP, "top-down-parent"}, ++ {AuWbrCopyup_BUP, "bup"}, ++ {AuWbrCopyup_BUP, "bottom-up-parent"}, ++ {AuWbrCopyup_BU, "bu"}, ++ {AuWbrCopyup_BU, "bottom-up"}, ++ {-1, NULL} ++}; ++ ++static int noinline_for_stack au_wbr_copyup_val(char *str) ++{ ++ substring_t args[MAX_OPT_ARGS]; ++ ++ return match_token(str, au_wbr_copyup_policy, args); ++} ++ ++const char *au_optstr_wbr_copyup(int wbr_copyup) ++{ ++ return au_parser_pattern(wbr_copyup, au_wbr_copyup_policy); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static const int lkup_dirflags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY; ++ ++static void dump_opts(struct au_opts *opts) ++{ ++#ifdef CONFIG_AUFS_DEBUG ++ /* reduce stack space */ ++ union { ++ struct au_opt_add *add; ++ struct au_opt_del *del; ++ struct au_opt_mod *mod; ++ struct au_opt_xino *xino; ++ struct au_opt_xino_itrunc *xino_itrunc; ++ struct au_opt_wbr_create *create; ++ } u; ++ struct au_opt *opt; ++ ++ opt = opts->opt; ++ while (opt->type != Opt_tail) { ++ switch (opt->type) { ++ case Opt_add: ++ u.add = &opt->add; ++ AuDbg("add {b%d, %s, 0x%x, %p}\n", ++ u.add->bindex, u.add->pathname, u.add->perm, ++ u.add->path.dentry); ++ break; ++ case Opt_del: ++ case Opt_idel: ++ u.del = &opt->del; ++ AuDbg("del {%s, %p}\n", ++ u.del->pathname, u.del->h_path.dentry); ++ break; ++ case Opt_mod: ++ case Opt_imod: ++ u.mod = &opt->mod; ++ AuDbg("mod {%s, 0x%x, %p}\n", ++ u.mod->path, u.mod->perm, u.mod->h_root); ++ break; ++ case Opt_append: ++ u.add = &opt->add; ++ AuDbg("append {b%d, %s, 0x%x, %p}\n", ++ u.add->bindex, u.add->pathname, u.add->perm, ++ u.add->path.dentry); ++ break; ++ case Opt_prepend: ++ u.add = &opt->add; ++ AuDbg("prepend {b%d, %s, 0x%x, %p}\n", ++ u.add->bindex, u.add->pathname, u.add->perm, ++ u.add->path.dentry); ++ break; ++ case Opt_dirwh: ++ AuDbg("dirwh %d\n", opt->dirwh); ++ break; ++ case Opt_rdcache: ++ AuDbg("rdcache %d\n", opt->rdcache); ++ break; ++ case Opt_rdblk: ++ AuDbg("rdblk %u\n", opt->rdblk); ++ break; ++ case Opt_rdblk_def: ++ AuDbg("rdblk_def\n"); ++ break; ++ case Opt_rdhash: ++ AuDbg("rdhash %u\n", opt->rdhash); ++ break; ++ case Opt_rdhash_def: ++ AuDbg("rdhash_def\n"); ++ break; ++ case Opt_xino: ++ u.xino = &opt->xino; ++ AuDbg("xino {%s %pD}\n", u.xino->path, u.xino->file); ++ break; ++ case Opt_trunc_xino: ++ AuLabel(trunc_xino); ++ break; ++ case Opt_notrunc_xino: ++ AuLabel(notrunc_xino); ++ break; ++ case Opt_trunc_xino_path: ++ case Opt_itrunc_xino: ++ u.xino_itrunc = &opt->xino_itrunc; ++ AuDbg("trunc_xino %d\n", u.xino_itrunc->bindex); ++ break; ++ case Opt_noxino: ++ AuLabel(noxino); ++ break; ++ case Opt_trunc_xib: ++ AuLabel(trunc_xib); ++ break; ++ case Opt_notrunc_xib: ++ AuLabel(notrunc_xib); ++ break; ++ case Opt_shwh: ++ AuLabel(shwh); ++ break; ++ case Opt_noshwh: ++ AuLabel(noshwh); ++ break; ++ case Opt_dirperm1: ++ AuLabel(dirperm1); ++ break; ++ case Opt_nodirperm1: ++ AuLabel(nodirperm1); ++ break; ++ case Opt_plink: ++ AuLabel(plink); ++ break; ++ case Opt_noplink: ++ AuLabel(noplink); ++ break; ++ case Opt_list_plink: ++ AuLabel(list_plink); ++ break; ++ case Opt_udba: ++ AuDbg("udba %d, %s\n", ++ opt->udba, au_optstr_udba(opt->udba)); ++ break; ++ case Opt_dio: ++ AuLabel(dio); ++ break; ++ case Opt_nodio: ++ AuLabel(nodio); ++ break; ++ case Opt_diropq_a: ++ AuLabel(diropq_a); ++ break; ++ case Opt_diropq_w: ++ AuLabel(diropq_w); ++ break; ++ case Opt_warn_perm: ++ AuLabel(warn_perm); ++ break; ++ case Opt_nowarn_perm: ++ AuLabel(nowarn_perm); ++ break; ++ case Opt_verbose: ++ AuLabel(verbose); ++ break; ++ case Opt_noverbose: ++ AuLabel(noverbose); ++ break; ++ case Opt_sum: ++ AuLabel(sum); ++ break; ++ case Opt_nosum: ++ AuLabel(nosum); ++ break; ++ case Opt_wsum: ++ AuLabel(wsum); ++ break; ++ case Opt_wbr_create: ++ u.create = &opt->wbr_create; ++ AuDbg("create %d, %s\n", u.create->wbr_create, ++ au_optstr_wbr_create(u.create->wbr_create)); ++ switch (u.create->wbr_create) { ++ case AuWbrCreate_MFSV: ++ case AuWbrCreate_PMFSV: ++ AuDbg("%d sec\n", u.create->mfs_second); ++ break; ++ case AuWbrCreate_MFSRR: ++ case AuWbrCreate_TDMFS: ++ AuDbg("%llu watermark\n", ++ u.create->mfsrr_watermark); ++ break; ++ case AuWbrCreate_MFSRRV: ++ case AuWbrCreate_TDMFSV: ++ case AuWbrCreate_PMFSRRV: ++ AuDbg("%llu watermark, %d sec\n", ++ u.create->mfsrr_watermark, ++ u.create->mfs_second); ++ break; ++ } ++ break; ++ case Opt_wbr_copyup: ++ AuDbg("copyup %d, %s\n", opt->wbr_copyup, ++ au_optstr_wbr_copyup(opt->wbr_copyup)); ++ break; ++ case Opt_fhsm_sec: ++ AuDbg("fhsm_sec %u\n", opt->fhsm_second); ++ break; ++ case Opt_dirren: ++ AuLabel(dirren); ++ break; ++ case Opt_nodirren: ++ AuLabel(nodirren); ++ break; ++ case Opt_acl: ++ AuLabel(acl); ++ break; ++ case Opt_noacl: ++ AuLabel(noacl); ++ break; ++ default: ++ BUG(); ++ } ++ opt++; ++ } ++#endif ++} ++ ++void au_opts_free(struct au_opts *opts) ++{ ++ struct au_opt *opt; ++ ++ opt = opts->opt; ++ while (opt->type != Opt_tail) { ++ switch (opt->type) { ++ case Opt_add: ++ case Opt_append: ++ case Opt_prepend: ++ path_put(&opt->add.path); ++ break; ++ case Opt_del: ++ case Opt_idel: ++ path_put(&opt->del.h_path); ++ break; ++ case Opt_mod: ++ case Opt_imod: ++ dput(opt->mod.h_root); ++ break; ++ case Opt_xino: ++ fput(opt->xino.file); ++ break; ++ } ++ opt++; ++ } ++} ++ ++static int opt_add(struct au_opt *opt, char *opt_str, unsigned long sb_flags, ++ aufs_bindex_t bindex) ++{ ++ int err; ++ struct au_opt_add *add = &opt->add; ++ char *p; ++ ++ add->bindex = bindex; ++ add->perm = AuBrPerm_RO; ++ add->pathname = opt_str; ++ p = strchr(opt_str, '='); ++ if (p) { ++ *p++ = 0; ++ if (*p) ++ add->perm = br_perm_val(p); ++ } ++ ++ err = vfsub_kern_path(add->pathname, lkup_dirflags, &add->path); ++ if (!err) { ++ if (!p) { ++ add->perm = AuBrPerm_RO; ++ if (au_test_fs_rr(add->path.dentry->d_sb)) ++ add->perm = AuBrPerm_RR; ++ else if (!bindex && !(sb_flags & SB_RDONLY)) ++ add->perm = AuBrPerm_RW; ++ } ++ opt->type = Opt_add; ++ goto out; ++ } ++ pr_err("lookup failed %s (%d)\n", add->pathname, err); ++ err = -EINVAL; ++ ++out: ++ return err; ++} ++ ++static int au_opts_parse_del(struct au_opt_del *del, substring_t args[]) ++{ ++ int err; ++ ++ del->pathname = args[0].from; ++ AuDbg("del path %s\n", del->pathname); ++ ++ err = vfsub_kern_path(del->pathname, lkup_dirflags, &del->h_path); ++ if (unlikely(err)) ++ pr_err("lookup failed %s (%d)\n", del->pathname, err); ++ ++ return err; ++} ++ ++#if 0 /* reserved for future use */ ++static int au_opts_parse_idel(struct super_block *sb, aufs_bindex_t bindex, ++ struct au_opt_del *del, substring_t args[]) ++{ ++ int err; ++ struct dentry *root; ++ ++ err = -EINVAL; ++ root = sb->s_root; ++ aufs_read_lock(root, AuLock_FLUSH); ++ if (bindex < 0 || au_sbbot(sb) < bindex) { ++ pr_err("out of bounds, %d\n", bindex); ++ goto out; ++ } ++ ++ err = 0; ++ del->h_path.dentry = dget(au_h_dptr(root, bindex)); ++ del->h_path.mnt = mntget(au_sbr_mnt(sb, bindex)); ++ ++out: ++ aufs_read_unlock(root, !AuLock_IR); ++ return err; ++} ++#endif ++ ++static int noinline_for_stack ++au_opts_parse_mod(struct au_opt_mod *mod, substring_t args[]) ++{ ++ int err; ++ struct path path; ++ char *p; ++ ++ err = -EINVAL; ++ mod->path = args[0].from; ++ p = strchr(mod->path, '='); ++ if (unlikely(!p)) { ++ pr_err("no permission %s\n", args[0].from); ++ goto out; ++ } ++ ++ *p++ = 0; ++ err = vfsub_kern_path(mod->path, lkup_dirflags, &path); ++ if (unlikely(err)) { ++ pr_err("lookup failed %s (%d)\n", mod->path, err); ++ goto out; ++ } ++ ++ mod->perm = br_perm_val(p); ++ AuDbg("mod path %s, perm 0x%x, %s\n", mod->path, mod->perm, p); ++ mod->h_root = dget(path.dentry); ++ path_put(&path); ++ ++out: ++ return err; ++} ++ ++#if 0 /* reserved for future use */ ++static int au_opts_parse_imod(struct super_block *sb, aufs_bindex_t bindex, ++ struct au_opt_mod *mod, substring_t args[]) ++{ ++ int err; ++ struct dentry *root; ++ ++ err = -EINVAL; ++ root = sb->s_root; ++ aufs_read_lock(root, AuLock_FLUSH); ++ if (bindex < 0 || au_sbbot(sb) < bindex) { ++ pr_err("out of bounds, %d\n", bindex); ++ goto out; ++ } ++ ++ err = 0; ++ mod->perm = br_perm_val(args[1].from); ++ AuDbg("mod path %s, perm 0x%x, %s\n", ++ mod->path, mod->perm, args[1].from); ++ mod->h_root = dget(au_h_dptr(root, bindex)); ++ ++out: ++ aufs_read_unlock(root, !AuLock_IR); ++ return err; ++} ++#endif ++ ++static int au_opts_parse_xino(struct super_block *sb, struct au_opt_xino *xino, ++ substring_t args[]) ++{ ++ int err; ++ struct file *file; ++ ++ file = au_xino_create(sb, args[0].from, /*silent*/0, /*wbrtop*/0); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ ++ err = -EINVAL; ++ if (unlikely(file->f_path.dentry->d_sb == sb)) { ++ fput(file); ++ pr_err("%s must be outside\n", args[0].from); ++ goto out; ++ } ++ ++ err = 0; ++ xino->file = file; ++ xino->path = args[0].from; ++ ++out: ++ return err; ++} ++ ++static int noinline_for_stack ++au_opts_parse_xino_itrunc_path(struct super_block *sb, ++ struct au_opt_xino_itrunc *xino_itrunc, ++ substring_t args[]) ++{ ++ int err; ++ aufs_bindex_t bbot, bindex; ++ struct path path; ++ struct dentry *root; ++ ++ err = vfsub_kern_path(args[0].from, lkup_dirflags, &path); ++ if (unlikely(err)) { ++ pr_err("lookup failed %s (%d)\n", args[0].from, err); ++ goto out; ++ } ++ ++ xino_itrunc->bindex = -1; ++ root = sb->s_root; ++ aufs_read_lock(root, AuLock_FLUSH); ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ if (au_h_dptr(root, bindex) == path.dentry) { ++ xino_itrunc->bindex = bindex; ++ break; ++ } ++ } ++ aufs_read_unlock(root, !AuLock_IR); ++ path_put(&path); ++ ++ if (unlikely(xino_itrunc->bindex < 0)) { ++ pr_err("no such branch %s\n", args[0].from); ++ err = -EINVAL; ++ } ++ ++out: ++ return err; ++} ++ ++/* called without aufs lock */ ++int au_opts_parse(struct super_block *sb, char *str, struct au_opts *opts) ++{ ++ int err, n, token; ++ aufs_bindex_t bindex; ++ unsigned char skipped; ++ struct dentry *root; ++ struct au_opt *opt, *opt_tail; ++ char *opt_str; ++ /* reduce the stack space */ ++ union { ++ struct au_opt_xino_itrunc *xino_itrunc; ++ struct au_opt_wbr_create *create; ++ } u; ++ struct { ++ substring_t args[MAX_OPT_ARGS]; ++ } *a; ++ ++ err = -ENOMEM; ++ a = kmalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ root = sb->s_root; ++ err = 0; ++ bindex = 0; ++ opt = opts->opt; ++ opt_tail = opt + opts->max_opt - 1; ++ opt->type = Opt_tail; ++ while (!err && (opt_str = strsep(&str, ",")) && *opt_str) { ++ err = -EINVAL; ++ skipped = 0; ++ token = match_token(opt_str, options, a->args); ++ switch (token) { ++ case Opt_br: ++ err = 0; ++ while (!err && (opt_str = strsep(&a->args[0].from, ":")) ++ && *opt_str) { ++ err = opt_add(opt, opt_str, opts->sb_flags, ++ bindex++); ++ if (unlikely(!err && ++opt > opt_tail)) { ++ err = -E2BIG; ++ break; ++ } ++ opt->type = Opt_tail; ++ skipped = 1; ++ } ++ break; ++ case Opt_add: ++ if (unlikely(match_int(&a->args[0], &n))) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ bindex = n; ++ err = opt_add(opt, a->args[1].from, opts->sb_flags, ++ bindex); ++ if (!err) ++ opt->type = token; ++ break; ++ case Opt_append: ++ err = opt_add(opt, a->args[0].from, opts->sb_flags, ++ /*dummy bindex*/1); ++ if (!err) ++ opt->type = token; ++ break; ++ case Opt_prepend: ++ err = opt_add(opt, a->args[0].from, opts->sb_flags, ++ /*bindex*/0); ++ if (!err) ++ opt->type = token; ++ break; ++ case Opt_del: ++ err = au_opts_parse_del(&opt->del, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#if 0 /* reserved for future use */ ++ case Opt_idel: ++ del->pathname = "(indexed)"; ++ if (unlikely(match_int(&args[0], &n))) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ err = au_opts_parse_idel(sb, n, &opt->del, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#endif ++ case Opt_mod: ++ err = au_opts_parse_mod(&opt->mod, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#ifdef IMOD /* reserved for future use */ ++ case Opt_imod: ++ u.mod->path = "(indexed)"; ++ if (unlikely(match_int(&a->args[0], &n))) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ err = au_opts_parse_imod(sb, n, &opt->mod, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#endif ++ case Opt_xino: ++ err = au_opts_parse_xino(sb, &opt->xino, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++ ++ case Opt_trunc_xino_path: ++ err = au_opts_parse_xino_itrunc_path ++ (sb, &opt->xino_itrunc, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++ ++ case Opt_itrunc_xino: ++ u.xino_itrunc = &opt->xino_itrunc; ++ if (unlikely(match_int(&a->args[0], &n))) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ u.xino_itrunc->bindex = n; ++ aufs_read_lock(root, AuLock_FLUSH); ++ if (n < 0 || au_sbbot(sb) < n) { ++ pr_err("out of bounds, %d\n", n); ++ aufs_read_unlock(root, !AuLock_IR); ++ break; ++ } ++ aufs_read_unlock(root, !AuLock_IR); ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_dirwh: ++ if (unlikely(match_int(&a->args[0], &opt->dirwh))) ++ break; ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_rdcache: ++ if (unlikely(match_int(&a->args[0], &n))) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ if (unlikely(n > AUFS_RDCACHE_MAX)) { ++ pr_err("rdcache must be smaller than %d\n", ++ AUFS_RDCACHE_MAX); ++ break; ++ } ++ opt->rdcache = n; ++ err = 0; ++ opt->type = token; ++ break; ++ case Opt_rdblk: ++ if (unlikely(match_int(&a->args[0], &n) ++ || n < 0 ++ || n > KMALLOC_MAX_SIZE)) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ if (unlikely(n && n < NAME_MAX)) { ++ pr_err("rdblk must be larger than %d\n", ++ NAME_MAX); ++ break; ++ } ++ opt->rdblk = n; ++ err = 0; ++ opt->type = token; ++ break; ++ case Opt_rdhash: ++ if (unlikely(match_int(&a->args[0], &n) ++ || n < 0 ++ || n * sizeof(struct hlist_head) ++ > KMALLOC_MAX_SIZE)) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ opt->rdhash = n; ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_trunc_xino: ++ case Opt_notrunc_xino: ++ case Opt_noxino: ++ case Opt_trunc_xib: ++ case Opt_notrunc_xib: ++ case Opt_shwh: ++ case Opt_noshwh: ++ case Opt_dirperm1: ++ case Opt_nodirperm1: ++ case Opt_plink: ++ case Opt_noplink: ++ case Opt_list_plink: ++ case Opt_dio: ++ case Opt_nodio: ++ case Opt_diropq_a: ++ case Opt_diropq_w: ++ case Opt_warn_perm: ++ case Opt_nowarn_perm: ++ case Opt_verbose: ++ case Opt_noverbose: ++ case Opt_sum: ++ case Opt_nosum: ++ case Opt_wsum: ++ case Opt_rdblk_def: ++ case Opt_rdhash_def: ++ case Opt_dirren: ++ case Opt_nodirren: ++ case Opt_acl: ++ case Opt_noacl: ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_udba: ++ opt->udba = udba_val(a->args[0].from); ++ if (opt->udba >= 0) { ++ err = 0; ++ opt->type = token; ++ } else ++ pr_err("wrong value, %s\n", opt_str); ++ break; ++ ++ case Opt_wbr_create: ++ u.create = &opt->wbr_create; ++ u.create->wbr_create ++ = au_wbr_create_val(a->args[0].from, u.create); ++ if (u.create->wbr_create >= 0) { ++ err = 0; ++ opt->type = token; ++ } else ++ pr_err("wrong value, %s\n", opt_str); ++ break; ++ case Opt_wbr_copyup: ++ opt->wbr_copyup = au_wbr_copyup_val(a->args[0].from); ++ if (opt->wbr_copyup >= 0) { ++ err = 0; ++ opt->type = token; ++ } else ++ pr_err("wrong value, %s\n", opt_str); ++ break; ++ ++ case Opt_fhsm_sec: ++ if (unlikely(match_int(&a->args[0], &n) ++ || n < 0)) { ++ pr_err("bad integer in %s\n", opt_str); ++ break; ++ } ++ if (sysaufs_brs) { ++ opt->fhsm_second = n; ++ opt->type = token; ++ } else ++ pr_warn("ignored %s\n", opt_str); ++ err = 0; ++ break; ++ ++ case Opt_ignore: ++ pr_warn("ignored %s\n", opt_str); ++ /*FALLTHROUGH*/ ++ case Opt_ignore_silent: ++ skipped = 1; ++ err = 0; ++ break; ++ case Opt_err: ++ pr_err("unknown option %s\n", opt_str); ++ break; ++ } ++ ++ if (!err && !skipped) { ++ if (unlikely(++opt > opt_tail)) { ++ err = -E2BIG; ++ opt--; ++ opt->type = Opt_tail; ++ break; ++ } ++ opt->type = Opt_tail; ++ } ++ } ++ ++ au_kfree_rcu(a); ++ dump_opts(opts); ++ if (unlikely(err)) ++ au_opts_free(opts); ++ ++out: ++ return err; ++} ++ ++static int au_opt_wbr_create(struct super_block *sb, ++ struct au_opt_wbr_create *create) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ ++ SiMustWriteLock(sb); ++ ++ err = 1; /* handled */ ++ sbinfo = au_sbi(sb); ++ if (sbinfo->si_wbr_create_ops->fin) { ++ err = sbinfo->si_wbr_create_ops->fin(sb); ++ if (!err) ++ err = 1; ++ } ++ ++ sbinfo->si_wbr_create = create->wbr_create; ++ sbinfo->si_wbr_create_ops = au_wbr_create_ops + create->wbr_create; ++ switch (create->wbr_create) { ++ case AuWbrCreate_MFSRRV: ++ case AuWbrCreate_MFSRR: ++ case AuWbrCreate_TDMFS: ++ case AuWbrCreate_TDMFSV: ++ case AuWbrCreate_PMFSRR: ++ case AuWbrCreate_PMFSRRV: ++ sbinfo->si_wbr_mfs.mfsrr_watermark = create->mfsrr_watermark; ++ /*FALLTHROUGH*/ ++ case AuWbrCreate_MFS: ++ case AuWbrCreate_MFSV: ++ case AuWbrCreate_PMFS: ++ case AuWbrCreate_PMFSV: ++ sbinfo->si_wbr_mfs.mfs_expire ++ = msecs_to_jiffies(create->mfs_second * MSEC_PER_SEC); ++ break; ++ } ++ ++ if (sbinfo->si_wbr_create_ops->init) ++ sbinfo->si_wbr_create_ops->init(sb); /* ignore */ ++ ++ return err; ++} ++ ++/* ++ * returns, ++ * plus: processed without an error ++ * zero: unprocessed ++ */ ++static int au_opt_simple(struct super_block *sb, struct au_opt *opt, ++ struct au_opts *opts) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ ++ SiMustWriteLock(sb); ++ ++ err = 1; /* handled */ ++ sbinfo = au_sbi(sb); ++ switch (opt->type) { ++ case Opt_udba: ++ sbinfo->si_mntflags &= ~AuOptMask_UDBA; ++ sbinfo->si_mntflags |= opt->udba; ++ opts->given_udba |= opt->udba; ++ break; ++ ++ case Opt_plink: ++ au_opt_set(sbinfo->si_mntflags, PLINK); ++ break; ++ case Opt_noplink: ++ if (au_opt_test(sbinfo->si_mntflags, PLINK)) ++ au_plink_put(sb, /*verbose*/1); ++ au_opt_clr(sbinfo->si_mntflags, PLINK); ++ break; ++ case Opt_list_plink: ++ if (au_opt_test(sbinfo->si_mntflags, PLINK)) ++ au_plink_list(sb); ++ break; ++ ++ case Opt_dio: ++ au_opt_set(sbinfo->si_mntflags, DIO); ++ au_fset_opts(opts->flags, REFRESH_DYAOP); ++ break; ++ case Opt_nodio: ++ au_opt_clr(sbinfo->si_mntflags, DIO); ++ au_fset_opts(opts->flags, REFRESH_DYAOP); ++ break; ++ ++ case Opt_fhsm_sec: ++ au_fhsm_set(sbinfo, opt->fhsm_second); ++ break; ++ ++ case Opt_diropq_a: ++ au_opt_set(sbinfo->si_mntflags, ALWAYS_DIROPQ); ++ break; ++ case Opt_diropq_w: ++ au_opt_clr(sbinfo->si_mntflags, ALWAYS_DIROPQ); ++ break; ++ ++ case Opt_warn_perm: ++ au_opt_set(sbinfo->si_mntflags, WARN_PERM); ++ break; ++ case Opt_nowarn_perm: ++ au_opt_clr(sbinfo->si_mntflags, WARN_PERM); ++ break; ++ ++ case Opt_verbose: ++ au_opt_set(sbinfo->si_mntflags, VERBOSE); ++ break; ++ case Opt_noverbose: ++ au_opt_clr(sbinfo->si_mntflags, VERBOSE); ++ break; ++ ++ case Opt_sum: ++ au_opt_set(sbinfo->si_mntflags, SUM); ++ break; ++ case Opt_wsum: ++ au_opt_clr(sbinfo->si_mntflags, SUM); ++ au_opt_set(sbinfo->si_mntflags, SUM_W); ++ break; ++ case Opt_nosum: ++ au_opt_clr(sbinfo->si_mntflags, SUM); ++ au_opt_clr(sbinfo->si_mntflags, SUM_W); ++ break; ++ ++ case Opt_wbr_create: ++ err = au_opt_wbr_create(sb, &opt->wbr_create); ++ break; ++ case Opt_wbr_copyup: ++ sbinfo->si_wbr_copyup = opt->wbr_copyup; ++ sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + opt->wbr_copyup; ++ break; ++ ++ case Opt_dirwh: ++ sbinfo->si_dirwh = opt->dirwh; ++ break; ++ ++ case Opt_rdcache: ++ sbinfo->si_rdcache ++ = msecs_to_jiffies(opt->rdcache * MSEC_PER_SEC); ++ break; ++ case Opt_rdblk: ++ sbinfo->si_rdblk = opt->rdblk; ++ break; ++ case Opt_rdblk_def: ++ sbinfo->si_rdblk = AUFS_RDBLK_DEF; ++ break; ++ case Opt_rdhash: ++ sbinfo->si_rdhash = opt->rdhash; ++ break; ++ case Opt_rdhash_def: ++ sbinfo->si_rdhash = AUFS_RDHASH_DEF; ++ break; ++ ++ case Opt_shwh: ++ au_opt_set(sbinfo->si_mntflags, SHWH); ++ break; ++ case Opt_noshwh: ++ au_opt_clr(sbinfo->si_mntflags, SHWH); ++ break; ++ ++ case Opt_dirperm1: ++ au_opt_set(sbinfo->si_mntflags, DIRPERM1); ++ break; ++ case Opt_nodirperm1: ++ au_opt_clr(sbinfo->si_mntflags, DIRPERM1); ++ break; ++ ++ case Opt_trunc_xino: ++ au_opt_set(sbinfo->si_mntflags, TRUNC_XINO); ++ break; ++ case Opt_notrunc_xino: ++ au_opt_clr(sbinfo->si_mntflags, TRUNC_XINO); ++ break; ++ ++ case Opt_trunc_xino_path: ++ case Opt_itrunc_xino: ++ err = au_xino_trunc(sb, opt->xino_itrunc.bindex, ++ /*idx_begin*/0); ++ if (!err) ++ err = 1; ++ break; ++ ++ case Opt_trunc_xib: ++ au_fset_opts(opts->flags, TRUNC_XIB); ++ break; ++ case Opt_notrunc_xib: ++ au_fclr_opts(opts->flags, TRUNC_XIB); ++ break; ++ ++ case Opt_dirren: ++ err = 1; ++ if (!au_opt_test(sbinfo->si_mntflags, DIRREN)) { ++ err = au_dr_opt_set(sb); ++ if (!err) ++ err = 1; ++ } ++ if (err == 1) ++ au_opt_set(sbinfo->si_mntflags, DIRREN); ++ break; ++ case Opt_nodirren: ++ err = 1; ++ if (au_opt_test(sbinfo->si_mntflags, DIRREN)) { ++ err = au_dr_opt_clr(sb, au_ftest_opts(opts->flags, ++ DR_FLUSHED)); ++ if (!err) ++ err = 1; ++ } ++ if (err == 1) ++ au_opt_clr(sbinfo->si_mntflags, DIRREN); ++ break; ++ ++ case Opt_acl: ++ sb->s_flags |= SB_POSIXACL; ++ break; ++ case Opt_noacl: ++ sb->s_flags &= ~SB_POSIXACL; ++ break; ++ ++ default: ++ err = 0; ++ break; ++ } ++ ++ return err; ++} ++ ++/* ++ * returns tri-state. ++ * plus: processed without an error ++ * zero: unprocessed ++ * minus: error ++ */ ++static int au_opt_br(struct super_block *sb, struct au_opt *opt, ++ struct au_opts *opts) ++{ ++ int err, do_refresh; ++ ++ err = 0; ++ switch (opt->type) { ++ case Opt_append: ++ opt->add.bindex = au_sbbot(sb) + 1; ++ if (opt->add.bindex < 0) ++ opt->add.bindex = 0; ++ goto add; ++ /* Always goto add, not fallthrough */ ++ case Opt_prepend: ++ opt->add.bindex = 0; ++ /* fallthrough */ ++ add: /* indented label */ ++ case Opt_add: ++ err = au_br_add(sb, &opt->add, ++ au_ftest_opts(opts->flags, REMOUNT)); ++ if (!err) { ++ err = 1; ++ au_fset_opts(opts->flags, REFRESH); ++ } ++ break; ++ ++ case Opt_del: ++ case Opt_idel: ++ err = au_br_del(sb, &opt->del, ++ au_ftest_opts(opts->flags, REMOUNT)); ++ if (!err) { ++ err = 1; ++ au_fset_opts(opts->flags, TRUNC_XIB); ++ au_fset_opts(opts->flags, REFRESH); ++ } ++ break; ++ ++ case Opt_mod: ++ case Opt_imod: ++ err = au_br_mod(sb, &opt->mod, ++ au_ftest_opts(opts->flags, REMOUNT), ++ &do_refresh); ++ if (!err) { ++ err = 1; ++ if (do_refresh) ++ au_fset_opts(opts->flags, REFRESH); ++ } ++ break; ++ } ++ return err; ++} ++ ++static int au_opt_xino(struct super_block *sb, struct au_opt *opt, ++ struct au_opt_xino **opt_xino, ++ struct au_opts *opts) ++{ ++ int err; ++ ++ err = 0; ++ switch (opt->type) { ++ case Opt_xino: ++ err = au_xino_set(sb, &opt->xino, ++ !!au_ftest_opts(opts->flags, REMOUNT)); ++ if (unlikely(err)) ++ break; ++ ++ *opt_xino = &opt->xino; ++ break; ++ ++ case Opt_noxino: ++ au_xino_clr(sb); ++ *opt_xino = (void *)-1; ++ break; ++ } ++ ++ return err; ++} ++ ++int au_opts_verify(struct super_block *sb, unsigned long sb_flags, ++ unsigned int pending) ++{ ++ int err, fhsm; ++ aufs_bindex_t bindex, bbot; ++ unsigned char do_plink, skip, do_free, can_no_dreval; ++ struct au_branch *br; ++ struct au_wbr *wbr; ++ struct dentry *root, *dentry; ++ struct inode *dir, *h_dir; ++ struct au_sbinfo *sbinfo; ++ struct au_hinode *hdir; ++ ++ SiMustAnyLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!(sbinfo->si_mntflags & AuOptMask_UDBA)); ++ ++ if (!(sb_flags & SB_RDONLY)) { ++ if (unlikely(!au_br_writable(au_sbr_perm(sb, 0)))) ++ pr_warn("first branch should be rw\n"); ++ if (unlikely(au_opt_test(sbinfo->si_mntflags, SHWH))) ++ pr_warn_once("shwh should be used with ro\n"); ++ } ++ ++ if (au_opt_test((sbinfo->si_mntflags | pending), UDBA_HNOTIFY) ++ && !au_opt_test(sbinfo->si_mntflags, XINO)) ++ pr_warn_once("udba=*notify requires xino\n"); ++ ++ if (au_opt_test(sbinfo->si_mntflags, DIRPERM1)) ++ pr_warn_once("dirperm1 breaks the protection" ++ " by the permission bits on the lower branch\n"); ++ ++ err = 0; ++ fhsm = 0; ++ root = sb->s_root; ++ dir = d_inode(root); ++ do_plink = !!au_opt_test(sbinfo->si_mntflags, PLINK); ++ can_no_dreval = !!au_opt_test((sbinfo->si_mntflags | pending), ++ UDBA_NONE); ++ bbot = au_sbbot(sb); ++ for (bindex = 0; !err && bindex <= bbot; bindex++) { ++ skip = 0; ++ h_dir = au_h_iptr(dir, bindex); ++ br = au_sbr(sb, bindex); ++ ++ if ((br->br_perm & AuBrAttr_ICEX) ++ && !h_dir->i_op->listxattr) ++ br->br_perm &= ~AuBrAttr_ICEX; ++#if 0 /* untested */ ++ if ((br->br_perm & AuBrAttr_ICEX_SEC) ++ && (au_br_sb(br)->s_flags & SB_NOSEC)) ++ br->br_perm &= ~AuBrAttr_ICEX_SEC; ++#endif ++ ++ do_free = 0; ++ wbr = br->br_wbr; ++ if (wbr) ++ wbr_wh_read_lock(wbr); ++ ++ if (!au_br_writable(br->br_perm)) { ++ do_free = !!wbr; ++ skip = (!wbr ++ || (!wbr->wbr_whbase ++ && !wbr->wbr_plink ++ && !wbr->wbr_orph)); ++ } else if (!au_br_wh_linkable(br->br_perm)) { ++ /* skip = (!br->br_whbase && !br->br_orph); */ ++ skip = (!wbr || !wbr->wbr_whbase); ++ if (skip && wbr) { ++ if (do_plink) ++ skip = !!wbr->wbr_plink; ++ else ++ skip = !wbr->wbr_plink; ++ } ++ } else { ++ /* skip = (br->br_whbase && br->br_ohph); */ ++ skip = (wbr && wbr->wbr_whbase); ++ if (skip) { ++ if (do_plink) ++ skip = !!wbr->wbr_plink; ++ else ++ skip = !wbr->wbr_plink; ++ } ++ } ++ if (wbr) ++ wbr_wh_read_unlock(wbr); ++ ++ if (can_no_dreval) { ++ dentry = br->br_path.dentry; ++ spin_lock(&dentry->d_lock); ++ if (dentry->d_flags & ++ (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE)) ++ can_no_dreval = 0; ++ spin_unlock(&dentry->d_lock); ++ } ++ ++ if (au_br_fhsm(br->br_perm)) { ++ fhsm++; ++ AuDebugOn(!br->br_fhsm); ++ } ++ ++ if (skip) ++ continue; ++ ++ hdir = au_hi(dir, bindex); ++ au_hn_inode_lock_nested(hdir, AuLsc_I_PARENT); ++ if (wbr) ++ wbr_wh_write_lock(wbr); ++ err = au_wh_init(br, sb); ++ if (wbr) ++ wbr_wh_write_unlock(wbr); ++ au_hn_inode_unlock(hdir); ++ ++ if (!err && do_free) { ++ au_kfree_rcu(wbr); ++ br->br_wbr = NULL; ++ } ++ } ++ ++ if (can_no_dreval) ++ au_fset_si(sbinfo, NO_DREVAL); ++ else ++ au_fclr_si(sbinfo, NO_DREVAL); ++ ++ if (fhsm >= 2) { ++ au_fset_si(sbinfo, FHSM); ++ for (bindex = bbot; bindex >= 0; bindex--) { ++ br = au_sbr(sb, bindex); ++ if (au_br_fhsm(br->br_perm)) { ++ au_fhsm_set_bottom(sb, bindex); ++ break; ++ } ++ } ++ } else { ++ au_fclr_si(sbinfo, FHSM); ++ au_fhsm_set_bottom(sb, -1); ++ } ++ ++ return err; ++} ++ ++int au_opts_mount(struct super_block *sb, struct au_opts *opts) ++{ ++ int err; ++ unsigned int tmp; ++ aufs_bindex_t bindex, bbot; ++ struct au_opt *opt; ++ struct au_opt_xino *opt_xino, xino; ++ struct au_sbinfo *sbinfo; ++ struct au_branch *br; ++ struct inode *dir; ++ ++ SiMustWriteLock(sb); ++ ++ err = 0; ++ opt_xino = NULL; ++ opt = opts->opt; ++ while (err >= 0 && opt->type != Opt_tail) ++ err = au_opt_simple(sb, opt++, opts); ++ if (err > 0) ++ err = 0; ++ else if (unlikely(err < 0)) ++ goto out; ++ ++ /* disable xino and udba temporary */ ++ sbinfo = au_sbi(sb); ++ tmp = sbinfo->si_mntflags; ++ au_opt_clr(sbinfo->si_mntflags, XINO); ++ au_opt_set_udba(sbinfo->si_mntflags, UDBA_REVAL); ++ ++ opt = opts->opt; ++ while (err >= 0 && opt->type != Opt_tail) ++ err = au_opt_br(sb, opt++, opts); ++ if (err > 0) ++ err = 0; ++ else if (unlikely(err < 0)) ++ goto out; ++ ++ bbot = au_sbbot(sb); ++ if (unlikely(bbot < 0)) { ++ err = -EINVAL; ++ pr_err("no branches\n"); ++ goto out; ++ } ++ ++ if (au_opt_test(tmp, XINO)) ++ au_opt_set(sbinfo->si_mntflags, XINO); ++ opt = opts->opt; ++ while (!err && opt->type != Opt_tail) ++ err = au_opt_xino(sb, opt++, &opt_xino, opts); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_opts_verify(sb, sb->s_flags, tmp); ++ if (unlikely(err)) ++ goto out; ++ ++ /* restore xino */ ++ if (au_opt_test(tmp, XINO) && !opt_xino) { ++ xino.file = au_xino_def(sb); ++ err = PTR_ERR(xino.file); ++ if (IS_ERR(xino.file)) ++ goto out; ++ ++ err = au_xino_set(sb, &xino, /*remount*/0); ++ fput(xino.file); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ /* restore udba */ ++ tmp &= AuOptMask_UDBA; ++ sbinfo->si_mntflags &= ~AuOptMask_UDBA; ++ sbinfo->si_mntflags |= tmp; ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ err = au_hnotify_reset_br(tmp, br, br->br_perm); ++ if (unlikely(err)) ++ AuIOErr("hnotify failed on br %d, %d, ignored\n", ++ bindex, err); ++ /* go on even if err */ ++ } ++ if (au_opt_test(tmp, UDBA_HNOTIFY)) { ++ dir = d_inode(sb->s_root); ++ au_hn_reset(dir, au_hi_flags(dir, /*isdir*/1) & ~AuHi_XINO); ++ } ++ ++out: ++ return err; ++} ++ ++int au_opts_remount(struct super_block *sb, struct au_opts *opts) ++{ ++ int err, rerr; ++ unsigned char no_dreval; ++ struct inode *dir; ++ struct au_opt_xino *opt_xino; ++ struct au_opt *opt; ++ struct au_sbinfo *sbinfo; ++ ++ SiMustWriteLock(sb); ++ ++ err = au_dr_opt_flush(sb); ++ if (unlikely(err)) ++ goto out; ++ au_fset_opts(opts->flags, DR_FLUSHED); ++ ++ dir = d_inode(sb->s_root); ++ sbinfo = au_sbi(sb); ++ opt_xino = NULL; ++ opt = opts->opt; ++ while (err >= 0 && opt->type != Opt_tail) { ++ err = au_opt_simple(sb, opt, opts); ++ if (!err) ++ err = au_opt_br(sb, opt, opts); ++ if (!err) ++ err = au_opt_xino(sb, opt, &opt_xino, opts); ++ opt++; ++ } ++ if (err > 0) ++ err = 0; ++ AuTraceErr(err); ++ /* go on even err */ ++ ++ no_dreval = !!au_ftest_si(sbinfo, NO_DREVAL); ++ rerr = au_opts_verify(sb, opts->sb_flags, /*pending*/0); ++ if (unlikely(rerr && !err)) ++ err = rerr; ++ ++ if (no_dreval != !!au_ftest_si(sbinfo, NO_DREVAL)) ++ au_fset_opts(opts->flags, REFRESH_IDOP); ++ ++ if (au_ftest_opts(opts->flags, TRUNC_XIB)) { ++ rerr = au_xib_trunc(sb); ++ if (unlikely(rerr && !err)) ++ err = rerr; ++ } ++ ++ /* will be handled by the caller */ ++ if (!au_ftest_opts(opts->flags, REFRESH) ++ && (opts->given_udba ++ || au_opt_test(sbinfo->si_mntflags, XINO) ++ || au_ftest_opts(opts->flags, REFRESH_IDOP) ++ )) ++ au_fset_opts(opts->flags, REFRESH); ++ ++ AuDbg("status 0x%x\n", opts->flags); ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++unsigned int au_opt_udba(struct super_block *sb) ++{ ++ return au_mntflags(sb) & AuOptMask_UDBA; ++} +diff --git a/fs/aufs/opts.h b/fs/aufs/opts.h +new file mode 100644 +index 000000000000..5e00aeac6d21 +--- /dev/null ++++ b/fs/aufs/opts.h +@@ -0,0 +1,212 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * mount options/flags ++ */ ++ ++#ifndef __AUFS_OPTS_H__ ++#define __AUFS_OPTS_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++ ++struct file; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* mount flags */ ++#define AuOpt_XINO 1 /* external inode number bitmap ++ and translation table */ ++#define AuOpt_TRUNC_XINO (1 << 1) /* truncate xino files */ ++#define AuOpt_UDBA_NONE (1 << 2) /* users direct branch access */ ++#define AuOpt_UDBA_REVAL (1 << 3) ++#define AuOpt_UDBA_HNOTIFY (1 << 4) ++#define AuOpt_SHWH (1 << 5) /* show whiteout */ ++#define AuOpt_PLINK (1 << 6) /* pseudo-link */ ++#define AuOpt_DIRPERM1 (1 << 7) /* ignore the lower dir's perm ++ bits */ ++#define AuOpt_ALWAYS_DIROPQ (1 << 9) /* policy to creating diropq */ ++#define AuOpt_SUM (1 << 10) /* summation for statfs(2) */ ++#define AuOpt_SUM_W (1 << 11) /* unimplemented */ ++#define AuOpt_WARN_PERM (1 << 12) /* warn when add-branch */ ++#define AuOpt_VERBOSE (1 << 13) /* print the cause of error */ ++#define AuOpt_DIO (1 << 14) /* direct io */ ++#define AuOpt_DIRREN (1 << 15) /* directory rename */ ++ ++#ifndef CONFIG_AUFS_HNOTIFY ++#undef AuOpt_UDBA_HNOTIFY ++#define AuOpt_UDBA_HNOTIFY 0 ++#endif ++#ifndef CONFIG_AUFS_DIRREN ++#undef AuOpt_DIRREN ++#define AuOpt_DIRREN 0 ++#endif ++#ifndef CONFIG_AUFS_SHWH ++#undef AuOpt_SHWH ++#define AuOpt_SHWH 0 ++#endif ++ ++#define AuOpt_Def (AuOpt_XINO \ ++ | AuOpt_UDBA_REVAL \ ++ | AuOpt_PLINK \ ++ /* | AuOpt_DIRPERM1 */ \ ++ | AuOpt_WARN_PERM) ++#define AuOptMask_UDBA (AuOpt_UDBA_NONE \ ++ | AuOpt_UDBA_REVAL \ ++ | AuOpt_UDBA_HNOTIFY) ++ ++#define au_opt_test(flags, name) (flags & AuOpt_##name) ++#define au_opt_set(flags, name) do { \ ++ BUILD_BUG_ON(AuOpt_##name & AuOptMask_UDBA); \ ++ ((flags) |= AuOpt_##name); \ ++} while (0) ++#define au_opt_set_udba(flags, name) do { \ ++ (flags) &= ~AuOptMask_UDBA; \ ++ ((flags) |= AuOpt_##name); \ ++} while (0) ++#define au_opt_clr(flags, name) do { \ ++ ((flags) &= ~AuOpt_##name); \ ++} while (0) ++ ++static inline unsigned int au_opts_plink(unsigned int mntflags) ++{ ++#ifdef CONFIG_PROC_FS ++ return mntflags; ++#else ++ return mntflags & ~AuOpt_PLINK; ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policies to select one among multiple writable branches */ ++enum { ++ AuWbrCreate_TDP, /* top down parent */ ++ AuWbrCreate_RR, /* round robin */ ++ AuWbrCreate_MFS, /* most free space */ ++ AuWbrCreate_MFSV, /* mfs with seconds */ ++ AuWbrCreate_MFSRR, /* mfs then rr */ ++ AuWbrCreate_MFSRRV, /* mfs then rr with seconds */ ++ AuWbrCreate_TDMFS, /* top down regardless parent and mfs */ ++ AuWbrCreate_TDMFSV, /* top down regardless parent and mfs */ ++ AuWbrCreate_PMFS, /* parent and mfs */ ++ AuWbrCreate_PMFSV, /* parent and mfs with seconds */ ++ AuWbrCreate_PMFSRR, /* parent, mfs and round-robin */ ++ AuWbrCreate_PMFSRRV, /* plus seconds */ ++ ++ AuWbrCreate_Def = AuWbrCreate_TDP ++}; ++ ++enum { ++ AuWbrCopyup_TDP, /* top down parent */ ++ AuWbrCopyup_BUP, /* bottom up parent */ ++ AuWbrCopyup_BU, /* bottom up */ ++ ++ AuWbrCopyup_Def = AuWbrCopyup_TDP ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_opt_add { ++ aufs_bindex_t bindex; ++ char *pathname; ++ int perm; ++ struct path path; ++}; ++ ++struct au_opt_del { ++ char *pathname; ++ struct path h_path; ++}; ++ ++struct au_opt_mod { ++ char *path; ++ int perm; ++ struct dentry *h_root; ++}; ++ ++struct au_opt_xino { ++ char *path; ++ struct file *file; ++}; ++ ++struct au_opt_xino_itrunc { ++ aufs_bindex_t bindex; ++}; ++ ++struct au_opt_wbr_create { ++ int wbr_create; ++ int mfs_second; ++ unsigned long long mfsrr_watermark; ++}; ++ ++struct au_opt { ++ int type; ++ union { ++ struct au_opt_xino xino; ++ struct au_opt_xino_itrunc xino_itrunc; ++ struct au_opt_add add; ++ struct au_opt_del del; ++ struct au_opt_mod mod; ++ int dirwh; ++ int rdcache; ++ unsigned int rdblk; ++ unsigned int rdhash; ++ int udba; ++ struct au_opt_wbr_create wbr_create; ++ int wbr_copyup; ++ unsigned int fhsm_second; ++ }; ++}; ++ ++/* opts flags */ ++#define AuOpts_REMOUNT 1 ++#define AuOpts_REFRESH (1 << 1) ++#define AuOpts_TRUNC_XIB (1 << 2) ++#define AuOpts_REFRESH_DYAOP (1 << 3) ++#define AuOpts_REFRESH_IDOP (1 << 4) ++#define AuOpts_DR_FLUSHED (1 << 5) ++#define au_ftest_opts(flags, name) ((flags) & AuOpts_##name) ++#define au_fset_opts(flags, name) \ ++ do { (flags) |= AuOpts_##name; } while (0) ++#define au_fclr_opts(flags, name) \ ++ do { (flags) &= ~AuOpts_##name; } while (0) ++ ++#ifndef CONFIG_AUFS_DIRREN ++#undef AuOpts_DR_FLUSHED ++#define AuOpts_DR_FLUSHED 0 ++#endif ++ ++struct au_opts { ++ struct au_opt *opt; ++ int max_opt; ++ ++ unsigned int given_udba; ++ unsigned int flags; ++ unsigned long sb_flags; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* opts.c */ ++void au_optstr_br_perm(au_br_perm_str_t *str, int perm); ++const char *au_optstr_udba(int udba); ++const char *au_optstr_wbr_copyup(int wbr_copyup); ++const char *au_optstr_wbr_create(int wbr_create); ++ ++void au_opts_free(struct au_opts *opts); ++struct super_block; ++int au_opts_parse(struct super_block *sb, char *str, struct au_opts *opts); ++int au_opts_verify(struct super_block *sb, unsigned long sb_flags, ++ unsigned int pending); ++int au_opts_mount(struct super_block *sb, struct au_opts *opts); ++int au_opts_remount(struct super_block *sb, struct au_opts *opts); ++ ++unsigned int au_opt_udba(struct super_block *sb); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_OPTS_H__ */ +diff --git a/fs/aufs/plink.c b/fs/aufs/plink.c +new file mode 100644 +index 000000000000..1c67183bebfb +--- /dev/null ++++ b/fs/aufs/plink.c +@@ -0,0 +1,503 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * pseudo-link ++ */ ++ ++#include "aufs.h" ++ ++/* ++ * the pseudo-link maintenance mode. ++ * during a user process maintains the pseudo-links, ++ * prohibit adding a new plink and branch manipulation. ++ * ++ * Flags ++ * NOPLM: ++ * For entry functions which will handle plink, and i_mutex is already held ++ * in VFS. ++ * They cannot wait and should return an error at once. ++ * Callers has to check the error. ++ * NOPLMW: ++ * For entry functions which will handle plink, but i_mutex is not held ++ * in VFS. ++ * They can wait the plink maintenance mode to finish. ++ * ++ * They behave like F_SETLK and F_SETLKW. ++ * If the caller never handle plink, then both flags are unnecessary. ++ */ ++ ++int au_plink_maint(struct super_block *sb, int flags) ++{ ++ int err; ++ pid_t pid, ppid; ++ struct task_struct *parent, *prev; ++ struct au_sbinfo *sbi; ++ ++ SiMustAnyLock(sb); ++ ++ err = 0; ++ if (!au_opt_test(au_mntflags(sb), PLINK)) ++ goto out; ++ ++ sbi = au_sbi(sb); ++ pid = sbi->si_plink_maint_pid; ++ if (!pid || pid == current->pid) ++ goto out; ++ ++ /* todo: it highly depends upon /sbin/mount.aufs */ ++ prev = NULL; ++ parent = current; ++ ppid = 0; ++ rcu_read_lock(); ++ while (1) { ++ parent = rcu_dereference(parent->real_parent); ++ if (parent == prev) ++ break; ++ ppid = task_pid_vnr(parent); ++ if (pid == ppid) { ++ rcu_read_unlock(); ++ goto out; ++ } ++ prev = parent; ++ } ++ rcu_read_unlock(); ++ ++ if (au_ftest_lock(flags, NOPLMW)) { ++ /* if there is no i_mutex lock in VFS, we don't need to wait */ ++ /* AuDebugOn(!lockdep_depth(current)); */ ++ while (sbi->si_plink_maint_pid) { ++ si_read_unlock(sb); ++ /* gave up wake_up_bit() */ ++ wait_event(sbi->si_plink_wq, !sbi->si_plink_maint_pid); ++ ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&sbi->si_nowait); ++ si_noflush_read_lock(sb); ++ } ++ } else if (au_ftest_lock(flags, NOPLM)) { ++ AuDbg("ppid %d, pid %d\n", ppid, pid); ++ err = -EAGAIN; ++ } ++ ++out: ++ return err; ++} ++ ++void au_plink_maint_leave(struct au_sbinfo *sbinfo) ++{ ++ spin_lock(&sbinfo->si_plink_maint_lock); ++ sbinfo->si_plink_maint_pid = 0; ++ spin_unlock(&sbinfo->si_plink_maint_lock); ++ wake_up_all(&sbinfo->si_plink_wq); ++} ++ ++int au_plink_maint_enter(struct super_block *sb) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ /* make sure i am the only one in this fs */ ++ si_write_lock(sb, AuLock_FLUSH); ++ if (au_opt_test(au_mntflags(sb), PLINK)) { ++ spin_lock(&sbinfo->si_plink_maint_lock); ++ if (!sbinfo->si_plink_maint_pid) ++ sbinfo->si_plink_maint_pid = current->pid; ++ else ++ err = -EBUSY; ++ spin_unlock(&sbinfo->si_plink_maint_lock); ++ } ++ si_write_unlock(sb); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_DEBUG ++void au_plink_list(struct super_block *sb) ++{ ++ int i; ++ struct au_sbinfo *sbinfo; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ struct au_icntnr *icntnr; ++ ++ SiMustAnyLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ AuDebugOn(au_plink_maint(sb, AuLock_NOPLM)); ++ ++ for (i = 0; i < AuPlink_NHASH; i++) { ++ hbl = sbinfo->si_plink + i; ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(icntnr, pos, hbl, plink) ++ AuDbg("%lu\n", icntnr->vfs_inode.i_ino); ++ hlist_bl_unlock(hbl); ++ } ++} ++#endif ++ ++/* is the inode pseudo-linked? */ ++int au_plink_test(struct inode *inode) ++{ ++ int found, i; ++ struct au_sbinfo *sbinfo; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ struct au_icntnr *icntnr; ++ ++ sbinfo = au_sbi(inode->i_sb); ++ AuRwMustAnyLock(&sbinfo->si_rwsem); ++ AuDebugOn(!au_opt_test(au_mntflags(inode->i_sb), PLINK)); ++ AuDebugOn(au_plink_maint(inode->i_sb, AuLock_NOPLM)); ++ ++ found = 0; ++ i = au_plink_hash(inode->i_ino); ++ hbl = sbinfo->si_plink + i; ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(icntnr, pos, hbl, plink) ++ if (&icntnr->vfs_inode == inode) { ++ found = 1; ++ break; ++ } ++ hlist_bl_unlock(hbl); ++ return found; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * generate a name for plink. ++ * the file will be stored under AUFS_WH_PLINKDIR. ++ */ ++/* 20 is max digits length of ulong 64 */ ++#define PLINK_NAME_LEN ((20 + 1) * 2) ++ ++static int plink_name(char *name, int len, struct inode *inode, ++ aufs_bindex_t bindex) ++{ ++ int rlen; ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, bindex); ++ rlen = snprintf(name, len, "%lu.%lu", inode->i_ino, h_inode->i_ino); ++ return rlen; ++} ++ ++struct au_do_plink_lkup_args { ++ struct dentry **errp; ++ struct qstr *tgtname; ++ struct dentry *h_parent; ++ struct au_branch *br; ++}; ++ ++static struct dentry *au_do_plink_lkup(struct qstr *tgtname, ++ struct dentry *h_parent, ++ struct au_branch *br) ++{ ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ ++ h_inode = d_inode(h_parent); ++ inode_lock_shared_nested(h_inode, AuLsc_I_CHILD2); ++ h_dentry = vfsub_lkup_one(tgtname, h_parent); ++ inode_unlock_shared(h_inode); ++ return h_dentry; ++} ++ ++static void au_call_do_plink_lkup(void *args) ++{ ++ struct au_do_plink_lkup_args *a = args; ++ *a->errp = au_do_plink_lkup(a->tgtname, a->h_parent, a->br); ++} ++ ++/* lookup the plink-ed @inode under the branch at @bindex */ ++struct dentry *au_plink_lkup(struct inode *inode, aufs_bindex_t bindex) ++{ ++ struct dentry *h_dentry, *h_parent; ++ struct au_branch *br; ++ int wkq_err; ++ char a[PLINK_NAME_LEN]; ++ struct qstr tgtname = QSTR_INIT(a, 0); ++ ++ AuDebugOn(au_plink_maint(inode->i_sb, AuLock_NOPLM)); ++ ++ br = au_sbr(inode->i_sb, bindex); ++ h_parent = br->br_wbr->wbr_plink; ++ tgtname.len = plink_name(a, sizeof(a), inode, bindex); ++ ++ if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID)) { ++ struct au_do_plink_lkup_args args = { ++ .errp = &h_dentry, ++ .tgtname = &tgtname, ++ .h_parent = h_parent, ++ .br = br ++ }; ++ ++ wkq_err = au_wkq_wait(au_call_do_plink_lkup, &args); ++ if (unlikely(wkq_err)) ++ h_dentry = ERR_PTR(wkq_err); ++ } else ++ h_dentry = au_do_plink_lkup(&tgtname, h_parent, br); ++ ++ return h_dentry; ++} ++ ++/* create a pseudo-link */ ++static int do_whplink(struct qstr *tgt, struct dentry *h_parent, ++ struct dentry *h_dentry, struct au_branch *br) ++{ ++ int err; ++ struct path h_path = { ++ .mnt = au_br_mnt(br) ++ }; ++ struct inode *h_dir, *delegated; ++ ++ h_dir = d_inode(h_parent); ++ inode_lock_nested(h_dir, AuLsc_I_CHILD2); ++again: ++ h_path.dentry = vfsub_lkup_one(tgt, h_parent); ++ err = PTR_ERR(h_path.dentry); ++ if (IS_ERR(h_path.dentry)) ++ goto out; ++ ++ err = 0; ++ /* wh.plink dir is not monitored */ ++ /* todo: is it really safe? */ ++ if (d_is_positive(h_path.dentry) ++ && d_inode(h_path.dentry) != d_inode(h_dentry)) { ++ delegated = NULL; ++ err = vfsub_unlink(h_dir, &h_path, &delegated, /*force*/0); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ dput(h_path.dentry); ++ h_path.dentry = NULL; ++ if (!err) ++ goto again; ++ } ++ if (!err && d_is_negative(h_path.dentry)) { ++ delegated = NULL; ++ err = vfsub_link(h_dentry, h_dir, &h_path, &delegated); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal link\n"); ++ iput(delegated); ++ } ++ } ++ dput(h_path.dentry); ++ ++out: ++ inode_unlock(h_dir); ++ return err; ++} ++ ++struct do_whplink_args { ++ int *errp; ++ struct qstr *tgt; ++ struct dentry *h_parent; ++ struct dentry *h_dentry; ++ struct au_branch *br; ++}; ++ ++static void call_do_whplink(void *args) ++{ ++ struct do_whplink_args *a = args; ++ *a->errp = do_whplink(a->tgt, a->h_parent, a->h_dentry, a->br); ++} ++ ++static int whplink(struct dentry *h_dentry, struct inode *inode, ++ aufs_bindex_t bindex, struct au_branch *br) ++{ ++ int err, wkq_err; ++ struct au_wbr *wbr; ++ struct dentry *h_parent; ++ char a[PLINK_NAME_LEN]; ++ struct qstr tgtname = QSTR_INIT(a, 0); ++ ++ wbr = au_sbr(inode->i_sb, bindex)->br_wbr; ++ h_parent = wbr->wbr_plink; ++ tgtname.len = plink_name(a, sizeof(a), inode, bindex); ++ ++ /* always superio. */ ++ if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID)) { ++ struct do_whplink_args args = { ++ .errp = &err, ++ .tgt = &tgtname, ++ .h_parent = h_parent, ++ .h_dentry = h_dentry, ++ .br = br ++ }; ++ wkq_err = au_wkq_wait(call_do_whplink, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } else ++ err = do_whplink(&tgtname, h_parent, h_dentry, br); ++ ++ return err; ++} ++ ++/* ++ * create a new pseudo-link for @h_dentry on @bindex. ++ * the linked inode is held in aufs @inode. ++ */ ++void au_plink_append(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_dentry) ++{ ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ struct au_icntnr *icntnr; ++ int found, err, cnt, i; ++ ++ sb = inode->i_sb; ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ AuDebugOn(au_plink_maint(sb, AuLock_NOPLM)); ++ ++ found = au_plink_test(inode); ++ if (found) ++ return; ++ ++ i = au_plink_hash(inode->i_ino); ++ hbl = sbinfo->si_plink + i; ++ au_igrab(inode); ++ ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry(icntnr, pos, hbl, plink) { ++ if (&icntnr->vfs_inode == inode) { ++ found = 1; ++ break; ++ } ++ } ++ if (!found) { ++ icntnr = container_of(inode, struct au_icntnr, vfs_inode); ++ hlist_bl_add_head(&icntnr->plink, hbl); ++ } ++ hlist_bl_unlock(hbl); ++ if (!found) { ++ cnt = au_hbl_count(hbl); ++#define msg "unexpectedly unbalanced or too many pseudo-links" ++ if (cnt > AUFS_PLINK_WARN) ++ AuWarn1(msg ", %d\n", cnt); ++#undef msg ++ err = whplink(h_dentry, inode, bindex, au_sbr(sb, bindex)); ++ if (unlikely(err)) { ++ pr_warn("err %d, damaged pseudo link.\n", err); ++ au_hbl_del(&icntnr->plink, hbl); ++ iput(&icntnr->vfs_inode); ++ } ++ } else ++ iput(&icntnr->vfs_inode); ++} ++ ++/* free all plinks */ ++void au_plink_put(struct super_block *sb, int verbose) ++{ ++ int i, warned; ++ struct au_sbinfo *sbinfo; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos, *tmp; ++ struct au_icntnr *icntnr; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ AuDebugOn(au_plink_maint(sb, AuLock_NOPLM)); ++ ++ /* no spin_lock since sbinfo is write-locked */ ++ warned = 0; ++ for (i = 0; i < AuPlink_NHASH; i++) { ++ hbl = sbinfo->si_plink + i; ++ if (!warned && verbose && !hlist_bl_empty(hbl)) { ++ pr_warn("pseudo-link is not flushed"); ++ warned = 1; ++ } ++ hlist_bl_for_each_entry_safe(icntnr, pos, tmp, hbl, plink) ++ iput(&icntnr->vfs_inode); ++ INIT_HLIST_BL_HEAD(hbl); ++ } ++} ++ ++void au_plink_clean(struct super_block *sb, int verbose) ++{ ++ struct dentry *root; ++ ++ root = sb->s_root; ++ aufs_write_lock(root); ++ if (au_opt_test(au_mntflags(sb), PLINK)) ++ au_plink_put(sb, verbose); ++ aufs_write_unlock(root); ++} ++ ++static int au_plink_do_half_refresh(struct inode *inode, aufs_bindex_t br_id) ++{ ++ int do_put; ++ aufs_bindex_t btop, bbot, bindex; ++ ++ do_put = 0; ++ btop = au_ibtop(inode); ++ bbot = au_ibbot(inode); ++ if (btop >= 0) { ++ for (bindex = btop; bindex <= bbot; bindex++) { ++ if (!au_h_iptr(inode, bindex) ++ || au_ii_br_id(inode, bindex) != br_id) ++ continue; ++ au_set_h_iptr(inode, bindex, NULL, 0); ++ do_put = 1; ++ break; ++ } ++ if (do_put) ++ for (bindex = btop; bindex <= bbot; bindex++) ++ if (au_h_iptr(inode, bindex)) { ++ do_put = 0; ++ break; ++ } ++ } else ++ do_put = 1; ++ ++ return do_put; ++} ++ ++/* free the plinks on a branch specified by @br_id */ ++void au_plink_half_refresh(struct super_block *sb, aufs_bindex_t br_id) ++{ ++ struct au_sbinfo *sbinfo; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos, *tmp; ++ struct au_icntnr *icntnr; ++ struct inode *inode; ++ int i, do_put; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ AuDebugOn(au_plink_maint(sb, AuLock_NOPLM)); ++ ++ /* no bit_lock since sbinfo is write-locked */ ++ for (i = 0; i < AuPlink_NHASH; i++) { ++ hbl = sbinfo->si_plink + i; ++ hlist_bl_for_each_entry_safe(icntnr, pos, tmp, hbl, plink) { ++ inode = au_igrab(&icntnr->vfs_inode); ++ ii_write_lock_child(inode); ++ do_put = au_plink_do_half_refresh(inode, br_id); ++ if (do_put) { ++ hlist_bl_del(&icntnr->plink); ++ iput(inode); ++ } ++ ii_write_unlock(inode); ++ iput(inode); ++ } ++ } ++} +diff --git a/fs/aufs/poll.c b/fs/aufs/poll.c +new file mode 100644 +index 000000000000..ff7697c334b4 +--- /dev/null ++++ b/fs/aufs/poll.c +@@ -0,0 +1,38 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * poll operation ++ * There is only one filesystem which implements ->poll operation, currently. ++ */ ++ ++#include "aufs.h" ++ ++__poll_t aufs_poll(struct file *file, struct poll_table_struct *pt) ++{ ++ __poll_t mask; ++ struct file *h_file; ++ struct super_block *sb; ++ ++ /* We should pretend an error happened. */ ++ mask = EPOLLERR /* | EPOLLIN | EPOLLOUT */; ++ sb = file->f_path.dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW); ++ ++ h_file = au_read_pre(file, /*keep_fi*/0, /*lsc*/0); ++ if (IS_ERR(h_file)) { ++ AuDbg("h_file %ld\n", PTR_ERR(h_file)); ++ goto out; ++ } ++ ++ mask = vfs_poll(h_file, pt); ++ fput(h_file); /* instead of au_read_post() */ ++ ++out: ++ si_read_unlock(sb); ++ if (mask & EPOLLERR) ++ AuDbg("mask 0x%x\n", mask); ++ return mask; ++} +diff --git a/fs/aufs/posix_acl.c b/fs/aufs/posix_acl.c +new file mode 100644 +index 000000000000..946c2247e78d +--- /dev/null ++++ b/fs/aufs/posix_acl.c +@@ -0,0 +1,92 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2014-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * posix acl operations ++ */ ++ ++#include ++#include "aufs.h" ++ ++struct posix_acl *aufs_get_acl(struct inode *inode, int type) ++{ ++ struct posix_acl *acl; ++ int err; ++ aufs_bindex_t bindex; ++ struct inode *h_inode; ++ struct super_block *sb; ++ ++ acl = NULL; ++ sb = inode->i_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ ii_read_lock_child(inode); ++ if (!(sb->s_flags & SB_POSIXACL)) ++ goto out; ++ ++ bindex = au_ibtop(inode); ++ h_inode = au_h_iptr(inode, bindex); ++ if (unlikely(!h_inode ++ || ((h_inode->i_mode & S_IFMT) ++ != (inode->i_mode & S_IFMT)))) { ++ err = au_busy_or_stale(); ++ acl = ERR_PTR(err); ++ goto out; ++ } ++ ++ /* always topmost only */ ++ acl = get_acl(h_inode, type); ++ if (IS_ERR(acl)) ++ forget_cached_acl(inode, type); ++ else ++ set_cached_acl(inode, type, acl); ++ ++out: ++ ii_read_unlock(inode); ++ si_read_unlock(sb); ++ ++ AuTraceErrPtr(acl); ++ return acl; ++} ++ ++int aufs_set_acl(struct inode *inode, struct posix_acl *acl, int type) ++{ ++ int err; ++ ssize_t ssz; ++ struct dentry *dentry; ++ struct au_sxattr arg = { ++ .type = AU_ACL_SET, ++ .u.acl_set = { ++ .acl = acl, ++ .type = type ++ }, ++ }; ++ ++ IMustLock(inode); ++ ++ if (inode->i_ino == AUFS_ROOT_INO) ++ dentry = dget(inode->i_sb->s_root); ++ else { ++ dentry = d_find_alias(inode); ++ if (!dentry) ++ dentry = d_find_any_alias(inode); ++ if (!dentry) { ++ pr_warn("cannot handle this inode, " ++ "please report to aufs-users ML\n"); ++ err = -ENOENT; ++ goto out; ++ } ++ } ++ ++ ssz = au_sxattr(dentry, inode, &arg); ++ /* forget even it if succeeds since the branch might set differently */ ++ forget_cached_acl(inode, type); ++ dput(dentry); ++ err = ssz; ++ if (ssz >= 0) ++ err = 0; ++ ++out: ++ return err; ++} +diff --git a/fs/aufs/procfs.c b/fs/aufs/procfs.c +new file mode 100644 +index 000000000000..055e9bcc9af4 +--- /dev/null ++++ b/fs/aufs/procfs.c +@@ -0,0 +1,157 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2010-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * procfs interfaces ++ */ ++ ++#include ++#include "aufs.h" ++ ++static int au_procfs_plm_release(struct inode *inode, struct file *file) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = file->private_data; ++ if (sbinfo) { ++ au_plink_maint_leave(sbinfo); ++ kobject_put(&sbinfo->si_kobj); ++ } ++ ++ return 0; ++} ++ ++static void au_procfs_plm_write_clean(struct file *file) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = file->private_data; ++ if (sbinfo) ++ au_plink_clean(sbinfo->si_sb, /*verbose*/0); ++} ++ ++static int au_procfs_plm_write_si(struct file *file, unsigned long id) ++{ ++ int err; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ struct hlist_bl_node *pos; ++ ++ err = -EBUSY; ++ if (unlikely(file->private_data)) ++ goto out; ++ ++ sb = NULL; ++ /* don't use au_sbilist_lock() here */ ++ hlist_bl_lock(&au_sbilist); ++ hlist_bl_for_each_entry(sbinfo, pos, &au_sbilist, si_list) ++ if (id == sysaufs_si_id(sbinfo)) { ++ if (kobject_get_unless_zero(&sbinfo->si_kobj)) ++ sb = sbinfo->si_sb; ++ break; ++ } ++ hlist_bl_unlock(&au_sbilist); ++ ++ err = -EINVAL; ++ if (unlikely(!sb)) ++ goto out; ++ ++ err = au_plink_maint_enter(sb); ++ if (!err) ++ /* keep kobject_get() */ ++ file->private_data = sbinfo; ++ else ++ kobject_put(&sbinfo->si_kobj); ++out: ++ return err; ++} ++ ++/* ++ * Accept a valid "si=xxxx" only. ++ * Once it is accepted successfully, accept "clean" too. ++ */ ++static ssize_t au_procfs_plm_write(struct file *file, const char __user *ubuf, ++ size_t count, loff_t *ppos) ++{ ++ ssize_t err; ++ unsigned long id; ++ /* last newline is allowed */ ++ char buf[3 + sizeof(unsigned long) * 2 + 1]; ++ ++ err = -EACCES; ++ if (unlikely(!capable(CAP_SYS_ADMIN))) ++ goto out; ++ ++ err = -EINVAL; ++ if (unlikely(count > sizeof(buf))) ++ goto out; ++ ++ err = copy_from_user(buf, ubuf, count); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ goto out; ++ } ++ buf[count] = 0; ++ ++ err = -EINVAL; ++ if (!strcmp("clean", buf)) { ++ au_procfs_plm_write_clean(file); ++ goto out_success; ++ } else if (unlikely(strncmp("si=", buf, 3))) ++ goto out; ++ ++ err = kstrtoul(buf + 3, 16, &id); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_procfs_plm_write_si(file, id); ++ if (unlikely(err)) ++ goto out; ++ ++out_success: ++ err = count; /* success */ ++out: ++ return err; ++} ++ ++static const struct proc_ops au_procfs_plm_op = { ++ .proc_write = au_procfs_plm_write, ++ .proc_release = au_procfs_plm_release ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct proc_dir_entry *au_procfs_dir; ++ ++void au_procfs_fin(void) ++{ ++ remove_proc_entry(AUFS_PLINK_MAINT_NAME, au_procfs_dir); ++ remove_proc_entry(AUFS_PLINK_MAINT_DIR, NULL); ++} ++ ++int __init au_procfs_init(void) ++{ ++ int err; ++ struct proc_dir_entry *entry; ++ ++ err = -ENOMEM; ++ au_procfs_dir = proc_mkdir(AUFS_PLINK_MAINT_DIR, NULL); ++ if (unlikely(!au_procfs_dir)) ++ goto out; ++ ++ entry = proc_create(AUFS_PLINK_MAINT_NAME, S_IFREG | 0200, ++ au_procfs_dir, &au_procfs_plm_op); ++ if (unlikely(!entry)) ++ goto out_dir; ++ ++ err = 0; ++ goto out; /* success */ ++ ++ ++out_dir: ++ remove_proc_entry(AUFS_PLINK_MAINT_DIR, NULL); ++out: ++ return err; ++} +diff --git a/fs/aufs/rdu.c b/fs/aufs/rdu.c +new file mode 100644 +index 000000000000..bef4607f057e +--- /dev/null ++++ b/fs/aufs/rdu.c +@@ -0,0 +1,371 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * readdir in userspace. ++ */ ++ ++#include ++#include ++#include ++#include "aufs.h" ++ ++/* bits for struct aufs_rdu.flags */ ++#define AuRdu_CALLED 1 ++#define AuRdu_CONT (1 << 1) ++#define AuRdu_FULL (1 << 2) ++#define au_ftest_rdu(flags, name) ((flags) & AuRdu_##name) ++#define au_fset_rdu(flags, name) \ ++ do { (flags) |= AuRdu_##name; } while (0) ++#define au_fclr_rdu(flags, name) \ ++ do { (flags) &= ~AuRdu_##name; } while (0) ++ ++struct au_rdu_arg { ++ struct dir_context ctx; ++ struct aufs_rdu *rdu; ++ union au_rdu_ent_ul ent; ++ unsigned long end; ++ ++ struct super_block *sb; ++ int err; ++}; ++ ++static int au_rdu_fill(struct dir_context *ctx, const char *name, int nlen, ++ loff_t offset, u64 h_ino, unsigned int d_type) ++{ ++ int err, len; ++ struct au_rdu_arg *arg = container_of(ctx, struct au_rdu_arg, ctx); ++ struct aufs_rdu *rdu = arg->rdu; ++ struct au_rdu_ent ent; ++ ++ err = 0; ++ arg->err = 0; ++ au_fset_rdu(rdu->cookie.flags, CALLED); ++ len = au_rdu_len(nlen); ++ if (arg->ent.ul + len < arg->end) { ++ ent.ino = h_ino; ++ ent.bindex = rdu->cookie.bindex; ++ ent.type = d_type; ++ ent.nlen = nlen; ++ if (unlikely(nlen > AUFS_MAX_NAMELEN)) ++ ent.type = DT_UNKNOWN; ++ ++ /* unnecessary to support mmap_sem since this is a dir */ ++ err = -EFAULT; ++ if (copy_to_user(arg->ent.e, &ent, sizeof(ent))) ++ goto out; ++ if (copy_to_user(arg->ent.e->name, name, nlen)) ++ goto out; ++ /* the terminating NULL */ ++ if (__put_user(0, arg->ent.e->name + nlen)) ++ goto out; ++ err = 0; ++ /* AuDbg("%p, %.*s\n", arg->ent.p, nlen, name); */ ++ arg->ent.ul += len; ++ rdu->rent++; ++ } else { ++ err = -EFAULT; ++ au_fset_rdu(rdu->cookie.flags, FULL); ++ rdu->full = 1; ++ rdu->tail = arg->ent; ++ } ++ ++out: ++ /* AuTraceErr(err); */ ++ return err; ++} ++ ++static int au_rdu_do(struct file *h_file, struct au_rdu_arg *arg) ++{ ++ int err; ++ loff_t offset; ++ struct au_rdu_cookie *cookie = &arg->rdu->cookie; ++ ++ /* we don't have to care (FMODE_32BITHASH | FMODE_64BITHASH) for ext4 */ ++ offset = vfsub_llseek(h_file, cookie->h_pos, SEEK_SET); ++ err = offset; ++ if (unlikely(offset != cookie->h_pos)) ++ goto out; ++ ++ err = 0; ++ do { ++ arg->err = 0; ++ au_fclr_rdu(cookie->flags, CALLED); ++ /* smp_mb(); */ ++ err = vfsub_iterate_dir(h_file, &arg->ctx); ++ if (err >= 0) ++ err = arg->err; ++ } while (!err ++ && au_ftest_rdu(cookie->flags, CALLED) ++ && !au_ftest_rdu(cookie->flags, FULL)); ++ cookie->h_pos = h_file->f_pos; ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_rdu(struct file *file, struct aufs_rdu *rdu) ++{ ++ int err; ++ aufs_bindex_t bbot; ++ struct au_rdu_arg arg = { ++ .ctx = { ++ .actor = au_rdu_fill ++ } ++ }; ++ struct dentry *dentry; ++ struct inode *inode; ++ struct file *h_file; ++ struct au_rdu_cookie *cookie = &rdu->cookie; ++ ++ /* VERIFY_WRITE */ ++ err = !access_ok(rdu->ent.e, rdu->sz); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ goto out; ++ } ++ rdu->rent = 0; ++ rdu->tail = rdu->ent; ++ rdu->full = 0; ++ arg.rdu = rdu; ++ arg.ent = rdu->ent; ++ arg.end = arg.ent.ul; ++ arg.end += rdu->sz; ++ ++ err = -ENOTDIR; ++ if (unlikely(!file->f_op->iterate && !file->f_op->iterate_shared)) ++ goto out; ++ ++ err = security_file_permission(file, MAY_READ); ++ AuTraceErr(err); ++ if (unlikely(err)) ++ goto out; ++ ++ dentry = file->f_path.dentry; ++ inode = d_inode(dentry); ++ inode_lock_shared(inode); ++ ++ arg.sb = inode->i_sb; ++ err = si_read_lock(arg.sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (unlikely(err)) ++ goto out_mtx; ++ err = au_alive_dir(dentry); ++ if (unlikely(err)) ++ goto out_si; ++ /* todo: reval? */ ++ fi_read_lock(file); ++ ++ err = -EAGAIN; ++ if (unlikely(au_ftest_rdu(cookie->flags, CONT) ++ && cookie->generation != au_figen(file))) ++ goto out_unlock; ++ ++ err = 0; ++ if (!rdu->blk) { ++ rdu->blk = au_sbi(arg.sb)->si_rdblk; ++ if (!rdu->blk) ++ rdu->blk = au_dir_size(file, /*dentry*/NULL); ++ } ++ bbot = au_fbtop(file); ++ if (cookie->bindex < bbot) ++ cookie->bindex = bbot; ++ bbot = au_fbbot_dir(file); ++ /* AuDbg("b%d, b%d\n", cookie->bindex, bbot); */ ++ for (; !err && cookie->bindex <= bbot; ++ cookie->bindex++, cookie->h_pos = 0) { ++ h_file = au_hf_dir(file, cookie->bindex); ++ if (!h_file) ++ continue; ++ ++ au_fclr_rdu(cookie->flags, FULL); ++ err = au_rdu_do(h_file, &arg); ++ AuTraceErr(err); ++ if (unlikely(au_ftest_rdu(cookie->flags, FULL) || err)) ++ break; ++ } ++ AuDbg("rent %llu\n", rdu->rent); ++ ++ if (!err && !au_ftest_rdu(cookie->flags, CONT)) { ++ rdu->shwh = !!au_opt_test(au_sbi(arg.sb)->si_mntflags, SHWH); ++ au_fset_rdu(cookie->flags, CONT); ++ cookie->generation = au_figen(file); ++ } ++ ++ ii_read_lock_child(inode); ++ fsstack_copy_attr_atime(inode, au_h_iptr(inode, au_ibtop(inode))); ++ ii_read_unlock(inode); ++ ++out_unlock: ++ fi_read_unlock(file); ++out_si: ++ si_read_unlock(arg.sb); ++out_mtx: ++ inode_unlock_shared(inode); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_rdu_ino(struct file *file, struct aufs_rdu *rdu) ++{ ++ int err; ++ ino_t ino; ++ unsigned long long nent; ++ union au_rdu_ent_ul *u; ++ struct au_rdu_ent ent; ++ struct super_block *sb; ++ ++ err = 0; ++ nent = rdu->nent; ++ u = &rdu->ent; ++ sb = file->f_path.dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ while (nent-- > 0) { ++ /* unnecessary to support mmap_sem since this is a dir */ ++ err = copy_from_user(&ent, u->e, sizeof(ent)); ++ if (!err) ++ /* VERIFY_WRITE */ ++ err = !access_ok(&u->e->ino, sizeof(ino)); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ break; ++ } ++ ++ /* AuDbg("b%d, i%llu\n", ent.bindex, ent.ino); */ ++ if (!ent.wh) ++ err = au_ino(sb, ent.bindex, ent.ino, ent.type, &ino); ++ else ++ err = au_wh_ino(sb, ent.bindex, ent.ino, ent.type, ++ &ino); ++ if (unlikely(err)) { ++ AuTraceErr(err); ++ break; ++ } ++ ++ err = __put_user(ino, &u->e->ino); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ break; ++ } ++ u->ul += au_rdu_len(ent.nlen); ++ } ++ si_read_unlock(sb); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_rdu_verify(struct aufs_rdu *rdu) ++{ ++ AuDbg("rdu{%llu, %p, %u | %u | %llu, %u, %u | " ++ "%llu, b%d, 0x%x, g%u}\n", ++ rdu->sz, rdu->ent.e, rdu->verify[AufsCtlRduV_SZ], ++ rdu->blk, ++ rdu->rent, rdu->shwh, rdu->full, ++ rdu->cookie.h_pos, rdu->cookie.bindex, rdu->cookie.flags, ++ rdu->cookie.generation); ++ ++ if (rdu->verify[AufsCtlRduV_SZ] == sizeof(*rdu)) ++ return 0; ++ ++ AuDbg("%u:%u\n", ++ rdu->verify[AufsCtlRduV_SZ], (unsigned int)sizeof(*rdu)); ++ return -EINVAL; ++} ++ ++long au_rdu_ioctl(struct file *file, unsigned int cmd, unsigned long arg) ++{ ++ long err, e; ++ struct aufs_rdu rdu; ++ void __user *p = (void __user *)arg; ++ ++ err = copy_from_user(&rdu, p, sizeof(rdu)); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ goto out; ++ } ++ err = au_rdu_verify(&rdu); ++ if (unlikely(err)) ++ goto out; ++ ++ switch (cmd) { ++ case AUFS_CTL_RDU: ++ err = au_rdu(file, &rdu); ++ if (unlikely(err)) ++ break; ++ ++ e = copy_to_user(p, &rdu, sizeof(rdu)); ++ if (unlikely(e)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ } ++ break; ++ case AUFS_CTL_RDU_INO: ++ err = au_rdu_ino(file, &rdu); ++ break; ++ ++ default: ++ /* err = -ENOTTY; */ ++ err = -EINVAL; ++ } ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++#ifdef CONFIG_COMPAT ++long au_rdu_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) ++{ ++ long err, e; ++ struct aufs_rdu rdu; ++ void __user *p = compat_ptr(arg); ++ ++ /* todo: get_user()? */ ++ err = copy_from_user(&rdu, p, sizeof(rdu)); ++ if (unlikely(err)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ goto out; ++ } ++ rdu.ent.e = compat_ptr(rdu.ent.ul); ++ err = au_rdu_verify(&rdu); ++ if (unlikely(err)) ++ goto out; ++ ++ switch (cmd) { ++ case AUFS_CTL_RDU: ++ err = au_rdu(file, &rdu); ++ if (unlikely(err)) ++ break; ++ ++ rdu.ent.ul = ptr_to_compat(rdu.ent.e); ++ rdu.tail.ul = ptr_to_compat(rdu.tail.e); ++ e = copy_to_user(p, &rdu, sizeof(rdu)); ++ if (unlikely(e)) { ++ err = -EFAULT; ++ AuTraceErr(err); ++ } ++ break; ++ case AUFS_CTL_RDU_INO: ++ err = au_rdu_ino(file, &rdu); ++ break; ++ ++ default: ++ /* err = -ENOTTY; */ ++ err = -EINVAL; ++ } ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++#endif +diff --git a/fs/aufs/rwsem.h b/fs/aufs/rwsem.h +new file mode 100644 +index 000000000000..ab5af8236699 +--- /dev/null ++++ b/fs/aufs/rwsem.h +@@ -0,0 +1,60 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * simple read-write semaphore wrappers ++ */ ++ ++#ifndef __AUFS_RWSEM_H__ ++#define __AUFS_RWSEM_H__ ++ ++#ifdef __KERNEL__ ++ ++#include "debug.h" ++ ++/* in the future, the name 'au_rwsem' will be totally gone */ ++#define au_rwsem rw_semaphore ++ ++/* to debug easier, do not make them inlined functions */ ++#define AuRwMustNoWaiters(rw) AuDebugOn(rwsem_is_contended(rw)) ++/* rwsem_is_locked() is unusable */ ++#define AuRwMustReadLock(rw) AuDebugOn(!lockdep_recursing(current) \ ++ && debug_locks \ ++ && !lockdep_is_held_type(rw, 1)) ++#define AuRwMustWriteLock(rw) AuDebugOn(!lockdep_recursing(current) \ ++ && debug_locks \ ++ && !lockdep_is_held_type(rw, 0)) ++#define AuRwMustAnyLock(rw) AuDebugOn(!lockdep_recursing(current) \ ++ && debug_locks \ ++ && !lockdep_is_held(rw)) ++#define AuRwDestroy(rw) AuDebugOn(!lockdep_recursing(current) \ ++ && debug_locks \ ++ && lockdep_is_held(rw)) ++ ++#define au_rw_init(rw) init_rwsem(rw) ++ ++#define au_rw_init_wlock(rw) do { \ ++ au_rw_init(rw); \ ++ down_write(rw); \ ++ } while (0) ++ ++#define au_rw_init_wlock_nested(rw, lsc) do { \ ++ au_rw_init(rw); \ ++ down_write_nested(rw, lsc); \ ++ } while (0) ++ ++#define au_rw_read_lock(rw) down_read(rw) ++#define au_rw_read_lock_nested(rw, lsc) down_read_nested(rw, lsc) ++#define au_rw_read_unlock(rw) up_read(rw) ++#define au_rw_dgrade_lock(rw) downgrade_write(rw) ++#define au_rw_write_lock(rw) down_write(rw) ++#define au_rw_write_lock_nested(rw, lsc) down_write_nested(rw, lsc) ++#define au_rw_write_unlock(rw) up_write(rw) ++/* why is not _nested version defined? */ ++#define au_rw_read_trylock(rw) down_read_trylock(rw) ++#define au_rw_write_trylock(rw) down_write_trylock(rw) ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_RWSEM_H__ */ +diff --git a/fs/aufs/sbinfo.c b/fs/aufs/sbinfo.c +new file mode 100644 +index 000000000000..26c6afab5df6 +--- /dev/null ++++ b/fs/aufs/sbinfo.c +@@ -0,0 +1,301 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * superblock private data ++ */ ++ ++#include ++#include "aufs.h" ++ ++/* ++ * they are necessary regardless sysfs is disabled. ++ */ ++void au_si_free(struct kobject *kobj) ++{ ++ int i; ++ struct au_sbinfo *sbinfo; ++ char *locked __maybe_unused; /* debug only */ ++ ++ sbinfo = container_of(kobj, struct au_sbinfo, si_kobj); ++ for (i = 0; i < AuPlink_NHASH; i++) ++ AuDebugOn(!hlist_bl_empty(sbinfo->si_plink + i)); ++ AuDebugOn(atomic_read(&sbinfo->si_nowait.nw_len)); ++ ++ AuLCntZero(au_lcnt_read(&sbinfo->si_ninodes, /*do_rev*/0)); ++ au_lcnt_fin(&sbinfo->si_ninodes, /*do_sync*/0); ++ AuLCntZero(au_lcnt_read(&sbinfo->si_nfiles, /*do_rev*/0)); ++ au_lcnt_fin(&sbinfo->si_nfiles, /*do_sync*/0); ++ ++ dbgaufs_si_fin(sbinfo); ++ au_rw_write_lock(&sbinfo->si_rwsem); ++ au_br_free(sbinfo); ++ au_rw_write_unlock(&sbinfo->si_rwsem); ++ ++ au_kfree_try_rcu(sbinfo->si_branch); ++ mutex_destroy(&sbinfo->si_xib_mtx); ++ AuRwDestroy(&sbinfo->si_rwsem); ++ ++ au_lcnt_wait_for_fin(&sbinfo->si_ninodes); ++ /* si_nfiles is waited too */ ++ au_kfree_rcu(sbinfo); ++} ++ ++int au_si_alloc(struct super_block *sb) ++{ ++ int err, i; ++ struct au_sbinfo *sbinfo; ++ ++ err = -ENOMEM; ++ sbinfo = kzalloc(sizeof(*sbinfo), GFP_NOFS); ++ if (unlikely(!sbinfo)) ++ goto out; ++ ++ /* will be reallocated separately */ ++ sbinfo->si_branch = kzalloc(sizeof(*sbinfo->si_branch), GFP_NOFS); ++ if (unlikely(!sbinfo->si_branch)) ++ goto out_sbinfo; ++ ++ err = sysaufs_si_init(sbinfo); ++ if (!err) { ++ dbgaufs_si_null(sbinfo); ++ err = dbgaufs_si_init(sbinfo); ++ if (unlikely(err)) ++ kobject_put(&sbinfo->si_kobj); ++ } ++ if (unlikely(err)) ++ goto out_br; ++ ++ au_nwt_init(&sbinfo->si_nowait); ++ au_rw_init_wlock(&sbinfo->si_rwsem); ++ ++ au_lcnt_init(&sbinfo->si_ninodes, /*release*/NULL); ++ au_lcnt_init(&sbinfo->si_nfiles, /*release*/NULL); ++ ++ sbinfo->si_bbot = -1; ++ sbinfo->si_last_br_id = AUFS_BRANCH_MAX / 2; ++ ++ sbinfo->si_wbr_copyup = AuWbrCopyup_Def; ++ sbinfo->si_wbr_create = AuWbrCreate_Def; ++ sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + sbinfo->si_wbr_copyup; ++ sbinfo->si_wbr_create_ops = au_wbr_create_ops + sbinfo->si_wbr_create; ++ ++ au_fhsm_init(sbinfo); ++ ++ sbinfo->si_mntflags = au_opts_plink(AuOpt_Def); ++ ++ sbinfo->si_xino_jiffy = jiffies; ++ sbinfo->si_xino_expire ++ = msecs_to_jiffies(AUFS_XINO_DEF_SEC * MSEC_PER_SEC); ++ mutex_init(&sbinfo->si_xib_mtx); ++ /* leave si_xib_last_pindex and si_xib_next_bit */ ++ ++ INIT_HLIST_BL_HEAD(&sbinfo->si_aopen); ++ ++ sbinfo->si_rdcache = msecs_to_jiffies(AUFS_RDCACHE_DEF * MSEC_PER_SEC); ++ sbinfo->si_rdblk = AUFS_RDBLK_DEF; ++ sbinfo->si_rdhash = AUFS_RDHASH_DEF; ++ sbinfo->si_dirwh = AUFS_DIRWH_DEF; ++ ++ for (i = 0; i < AuPlink_NHASH; i++) ++ INIT_HLIST_BL_HEAD(sbinfo->si_plink + i); ++ init_waitqueue_head(&sbinfo->si_plink_wq); ++ spin_lock_init(&sbinfo->si_plink_maint_lock); ++ ++ INIT_HLIST_BL_HEAD(&sbinfo->si_files); ++ ++ /* with getattr by default */ ++ sbinfo->si_iop_array = aufs_iop; ++ ++ /* leave other members for sysaufs and si_mnt. */ ++ sbinfo->si_sb = sb; ++ sb->s_fs_info = sbinfo; ++ si_pid_set(sb); ++ return 0; /* success */ ++ ++out_br: ++ au_kfree_try_rcu(sbinfo->si_branch); ++out_sbinfo: ++ au_kfree_rcu(sbinfo); ++out: ++ return err; ++} ++ ++int au_sbr_realloc(struct au_sbinfo *sbinfo, int nbr, int may_shrink) ++{ ++ int err, sz; ++ struct au_branch **brp; ++ ++ AuRwMustWriteLock(&sbinfo->si_rwsem); ++ ++ err = -ENOMEM; ++ sz = sizeof(*brp) * (sbinfo->si_bbot + 1); ++ if (unlikely(!sz)) ++ sz = sizeof(*brp); ++ brp = au_kzrealloc(sbinfo->si_branch, sz, sizeof(*brp) * nbr, GFP_NOFS, ++ may_shrink); ++ if (brp) { ++ sbinfo->si_branch = brp; ++ err = 0; ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++unsigned int au_sigen_inc(struct super_block *sb) ++{ ++ unsigned int gen; ++ struct inode *inode; ++ ++ SiMustWriteLock(sb); ++ ++ gen = ++au_sbi(sb)->si_generation; ++ au_update_digen(sb->s_root); ++ inode = d_inode(sb->s_root); ++ au_update_iigen(inode, /*half*/0); ++ inode_inc_iversion(inode); ++ return gen; ++} ++ ++aufs_bindex_t au_new_br_id(struct super_block *sb) ++{ ++ aufs_bindex_t br_id; ++ int i; ++ struct au_sbinfo *sbinfo; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ for (i = 0; i <= AUFS_BRANCH_MAX; i++) { ++ br_id = ++sbinfo->si_last_br_id; ++ AuDebugOn(br_id < 0); ++ if (br_id && au_br_index(sb, br_id) < 0) ++ return br_id; ++ } ++ ++ return -1; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* it is ok that new 'nwt' tasks are appended while we are sleeping */ ++int si_read_lock(struct super_block *sb, int flags) ++{ ++ int err; ++ ++ err = 0; ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ ++ si_noflush_read_lock(sb); ++ err = au_plink_maint(sb, flags); ++ if (unlikely(err)) ++ si_read_unlock(sb); ++ ++ return err; ++} ++ ++int si_write_lock(struct super_block *sb, int flags) ++{ ++ int err; ++ ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ ++ si_noflush_write_lock(sb); ++ err = au_plink_maint(sb, flags); ++ if (unlikely(err)) ++ si_write_unlock(sb); ++ ++ return err; ++} ++ ++/* dentry and super_block lock. call at entry point */ ++int aufs_read_lock(struct dentry *dentry, int flags) ++{ ++ int err; ++ struct super_block *sb; ++ ++ sb = dentry->d_sb; ++ err = si_read_lock(sb, flags); ++ if (unlikely(err)) ++ goto out; ++ ++ if (au_ftest_lock(flags, DW)) ++ di_write_lock_child(dentry); ++ else ++ di_read_lock_child(dentry, flags); ++ ++ if (au_ftest_lock(flags, GEN)) { ++ err = au_digen_test(dentry, au_sigen(sb)); ++ if (!au_opt_test(au_mntflags(sb), UDBA_NONE)) ++ AuDebugOn(!err && au_dbrange_test(dentry)); ++ else if (!err) ++ err = au_dbrange_test(dentry); ++ if (unlikely(err)) ++ aufs_read_unlock(dentry, flags); ++ } ++ ++out: ++ return err; ++} ++ ++void aufs_read_unlock(struct dentry *dentry, int flags) ++{ ++ if (au_ftest_lock(flags, DW)) ++ di_write_unlock(dentry); ++ else ++ di_read_unlock(dentry, flags); ++ si_read_unlock(dentry->d_sb); ++} ++ ++void aufs_write_lock(struct dentry *dentry) ++{ ++ si_write_lock(dentry->d_sb, AuLock_FLUSH | AuLock_NOPLMW); ++ di_write_lock_child(dentry); ++} ++ ++void aufs_write_unlock(struct dentry *dentry) ++{ ++ di_write_unlock(dentry); ++ si_write_unlock(dentry->d_sb); ++} ++ ++int aufs_read_and_write_lock2(struct dentry *d1, struct dentry *d2, int flags) ++{ ++ int err; ++ unsigned int sigen; ++ struct super_block *sb; ++ ++ sb = d1->d_sb; ++ err = si_read_lock(sb, flags); ++ if (unlikely(err)) ++ goto out; ++ ++ di_write_lock2_child(d1, d2, au_ftest_lock(flags, DIRS)); ++ ++ if (au_ftest_lock(flags, GEN)) { ++ sigen = au_sigen(sb); ++ err = au_digen_test(d1, sigen); ++ AuDebugOn(!err && au_dbrange_test(d1)); ++ if (!err) { ++ err = au_digen_test(d2, sigen); ++ AuDebugOn(!err && au_dbrange_test(d2)); ++ } ++ if (unlikely(err)) ++ aufs_read_and_write_unlock2(d1, d2); ++ } ++ ++out: ++ return err; ++} ++ ++void aufs_read_and_write_unlock2(struct dentry *d1, struct dentry *d2) ++{ ++ di_write_unlock2(d1, d2); ++ si_read_unlock(d1->d_sb); ++} +diff --git a/fs/aufs/super.c b/fs/aufs/super.c +new file mode 100644 +index 000000000000..589dd0122020 +--- /dev/null ++++ b/fs/aufs/super.c +@@ -0,0 +1,1034 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * mount and super_block operations ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include "aufs.h" ++ ++/* ++ * super_operations ++ */ ++static struct inode *aufs_alloc_inode(struct super_block *sb __maybe_unused) ++{ ++ struct au_icntnr *c; ++ ++ c = au_cache_alloc_icntnr(); ++ if (c) { ++ au_icntnr_init(c); ++ inode_set_iversion(&c->vfs_inode, 1); /* sigen(sb); */ ++ c->iinfo.ii_hinode = NULL; ++ return &c->vfs_inode; ++ } ++ return NULL; ++} ++ ++static void aufs_destroy_inode(struct inode *inode) ++{ ++ if (!au_is_bad_inode(inode)) ++ au_iinfo_fin(inode); ++} ++ ++static void aufs_free_inode(struct inode *inode) ++{ ++ au_cache_free_icntnr(container_of(inode, struct au_icntnr, vfs_inode)); ++} ++ ++struct inode *au_iget_locked(struct super_block *sb, ino_t ino) ++{ ++ struct inode *inode; ++ int err; ++ ++ inode = iget_locked(sb, ino); ++ if (unlikely(!inode)) { ++ inode = ERR_PTR(-ENOMEM); ++ goto out; ++ } ++ if (!(inode->i_state & I_NEW)) ++ goto out; ++ ++ err = au_xigen_new(inode); ++ if (!err) ++ err = au_iinfo_init(inode); ++ if (!err) ++ inode_inc_iversion(inode); ++ else { ++ iget_failed(inode); ++ inode = ERR_PTR(err); ++ } ++ ++out: ++ /* never return NULL */ ++ AuDebugOn(!inode); ++ AuTraceErrPtr(inode); ++ return inode; ++} ++ ++/* lock free root dinfo */ ++static int au_show_brs(struct seq_file *seq, struct super_block *sb) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ struct path path; ++ struct au_hdentry *hdp; ++ struct au_branch *br; ++ au_br_perm_str_t perm; ++ ++ err = 0; ++ bbot = au_sbbot(sb); ++ bindex = 0; ++ hdp = au_hdentry(au_di(sb->s_root), bindex); ++ for (; !err && bindex <= bbot; bindex++, hdp++) { ++ br = au_sbr(sb, bindex); ++ path.mnt = au_br_mnt(br); ++ path.dentry = hdp->hd_dentry; ++ err = au_seq_path(seq, &path); ++ if (!err) { ++ au_optstr_br_perm(&perm, br->br_perm); ++ seq_printf(seq, "=%s", perm.a); ++ if (bindex != bbot) ++ seq_putc(seq, ':'); ++ } ++ } ++ if (unlikely(err || seq_has_overflowed(seq))) ++ err = -E2BIG; ++ ++ return err; ++} ++ ++static void au_gen_fmt(char *fmt, int len __maybe_unused, const char *pat, ++ const char *append) ++{ ++ char *p; ++ ++ p = fmt; ++ while (*pat != ':') ++ *p++ = *pat++; ++ *p++ = *pat++; ++ strcpy(p, append); ++ AuDebugOn(strlen(fmt) >= len); ++} ++ ++static void au_show_wbr_create(struct seq_file *m, int v, ++ struct au_sbinfo *sbinfo) ++{ ++ const char *pat; ++ char fmt[32]; ++ struct au_wbr_mfs *mfs; ++ ++ AuRwMustAnyLock(&sbinfo->si_rwsem); ++ ++ seq_puts(m, ",create="); ++ pat = au_optstr_wbr_create(v); ++ mfs = &sbinfo->si_wbr_mfs; ++ switch (v) { ++ case AuWbrCreate_TDP: ++ case AuWbrCreate_RR: ++ case AuWbrCreate_MFS: ++ case AuWbrCreate_PMFS: ++ seq_puts(m, pat); ++ break; ++ case AuWbrCreate_MFSRR: ++ case AuWbrCreate_TDMFS: ++ case AuWbrCreate_PMFSRR: ++ au_gen_fmt(fmt, sizeof(fmt), pat, "%llu"); ++ seq_printf(m, fmt, mfs->mfsrr_watermark); ++ break; ++ case AuWbrCreate_MFSV: ++ case AuWbrCreate_PMFSV: ++ au_gen_fmt(fmt, sizeof(fmt), pat, "%lu"); ++ seq_printf(m, fmt, ++ jiffies_to_msecs(mfs->mfs_expire) ++ / MSEC_PER_SEC); ++ break; ++ case AuWbrCreate_MFSRRV: ++ case AuWbrCreate_TDMFSV: ++ case AuWbrCreate_PMFSRRV: ++ au_gen_fmt(fmt, sizeof(fmt), pat, "%llu:%lu"); ++ seq_printf(m, fmt, mfs->mfsrr_watermark, ++ jiffies_to_msecs(mfs->mfs_expire) / MSEC_PER_SEC); ++ break; ++ default: ++ BUG(); ++ } ++} ++ ++static int au_show_xino(struct seq_file *seq, struct super_block *sb) ++{ ++#ifdef CONFIG_SYSFS ++ return 0; ++#else ++ int err; ++ const int len = sizeof(AUFS_XINO_FNAME) - 1; ++ aufs_bindex_t bindex, brid; ++ struct qstr *name; ++ struct file *f; ++ struct dentry *d, *h_root; ++ struct au_branch *br; ++ ++ AuRwMustAnyLock(&sbinfo->si_rwsem); ++ ++ err = 0; ++ f = au_sbi(sb)->si_xib; ++ if (!f) ++ goto out; ++ ++ /* stop printing the default xino path on the first writable branch */ ++ h_root = NULL; ++ bindex = au_xi_root(sb, f->f_path.dentry); ++ if (bindex >= 0) { ++ br = au_sbr_sb(sb, bindex); ++ h_root = au_br_dentry(br); ++ } ++ ++ d = f->f_path.dentry; ++ name = &d->d_name; ++ /* safe ->d_parent because the file is unlinked */ ++ if (d->d_parent == h_root ++ && name->len == len ++ && !memcmp(name->name, AUFS_XINO_FNAME, len)) ++ goto out; ++ ++ seq_puts(seq, ",xino="); ++ err = au_xino_path(seq, f); ++ ++out: ++ return err; ++#endif ++} ++ ++/* seq_file will re-call me in case of too long string */ ++static int aufs_show_options(struct seq_file *m, struct dentry *dentry) ++{ ++ int err; ++ unsigned int mnt_flags, v; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++#define AuBool(name, str) do { \ ++ v = au_opt_test(mnt_flags, name); \ ++ if (v != au_opt_test(AuOpt_Def, name)) \ ++ seq_printf(m, ",%s" #str, v ? "" : "no"); \ ++} while (0) ++ ++#define AuStr(name, str) do { \ ++ v = mnt_flags & AuOptMask_##name; \ ++ if (v != (AuOpt_Def & AuOptMask_##name)) \ ++ seq_printf(m, "," #str "=%s", au_optstr_##str(v)); \ ++} while (0) ++ ++#define AuUInt(name, str, val) do { \ ++ if (val != AUFS_##name##_DEF) \ ++ seq_printf(m, "," #str "=%u", val); \ ++} while (0) ++ ++ sb = dentry->d_sb; ++ if (sb->s_flags & SB_POSIXACL) ++ seq_puts(m, ",acl"); ++#if 0 /* reserved for future use */ ++ if (sb->s_flags & SB_I_VERSION) ++ seq_puts(m, ",i_version"); ++#endif ++ ++ /* lock free root dinfo */ ++ si_noflush_read_lock(sb); ++ sbinfo = au_sbi(sb); ++ seq_printf(m, ",si=%lx", sysaufs_si_id(sbinfo)); ++ ++ mnt_flags = au_mntflags(sb); ++ if (au_opt_test(mnt_flags, XINO)) { ++ err = au_show_xino(m, sb); ++ if (unlikely(err)) ++ goto out; ++ } else ++ seq_puts(m, ",noxino"); ++ ++ AuBool(TRUNC_XINO, trunc_xino); ++ AuStr(UDBA, udba); ++ AuBool(SHWH, shwh); ++ AuBool(PLINK, plink); ++ AuBool(DIO, dio); ++ AuBool(DIRPERM1, dirperm1); ++ ++ v = sbinfo->si_wbr_create; ++ if (v != AuWbrCreate_Def) ++ au_show_wbr_create(m, v, sbinfo); ++ ++ v = sbinfo->si_wbr_copyup; ++ if (v != AuWbrCopyup_Def) ++ seq_printf(m, ",cpup=%s", au_optstr_wbr_copyup(v)); ++ ++ v = au_opt_test(mnt_flags, ALWAYS_DIROPQ); ++ if (v != au_opt_test(AuOpt_Def, ALWAYS_DIROPQ)) ++ seq_printf(m, ",diropq=%c", v ? 'a' : 'w'); ++ ++ AuUInt(DIRWH, dirwh, sbinfo->si_dirwh); ++ ++ v = jiffies_to_msecs(sbinfo->si_rdcache) / MSEC_PER_SEC; ++ AuUInt(RDCACHE, rdcache, v); ++ ++ AuUInt(RDBLK, rdblk, sbinfo->si_rdblk); ++ AuUInt(RDHASH, rdhash, sbinfo->si_rdhash); ++ ++ au_fhsm_show(m, sbinfo); ++ ++ AuBool(DIRREN, dirren); ++ AuBool(SUM, sum); ++ /* AuBool(SUM_W, wsum); */ ++ AuBool(WARN_PERM, warn_perm); ++ AuBool(VERBOSE, verbose); ++ ++out: ++ /* be sure to print "br:" last */ ++ if (!sysaufs_brs) { ++ seq_puts(m, ",br:"); ++ au_show_brs(m, sb); ++ } ++ si_read_unlock(sb); ++ return 0; ++ ++#undef AuBool ++#undef AuStr ++#undef AuUInt ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* sum mode which returns the summation for statfs(2) */ ++ ++static u64 au_add_till_max(u64 a, u64 b) ++{ ++ u64 old; ++ ++ old = a; ++ a += b; ++ if (old <= a) ++ return a; ++ return ULLONG_MAX; ++} ++ ++static u64 au_mul_till_max(u64 a, long mul) ++{ ++ u64 old; ++ ++ old = a; ++ a *= mul; ++ if (old <= a) ++ return a; ++ return ULLONG_MAX; ++} ++ ++static int au_statfs_sum(struct super_block *sb, struct kstatfs *buf) ++{ ++ int err; ++ long bsize, factor; ++ u64 blocks, bfree, bavail, files, ffree; ++ aufs_bindex_t bbot, bindex, i; ++ unsigned char shared; ++ struct path h_path; ++ struct super_block *h_sb; ++ ++ err = 0; ++ bsize = LONG_MAX; ++ files = 0; ++ ffree = 0; ++ blocks = 0; ++ bfree = 0; ++ bavail = 0; ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ h_path.mnt = au_sbr_mnt(sb, bindex); ++ h_sb = h_path.mnt->mnt_sb; ++ shared = 0; ++ for (i = 0; !shared && i < bindex; i++) ++ shared = (au_sbr_sb(sb, i) == h_sb); ++ if (shared) ++ continue; ++ ++ /* sb->s_root for NFS is unreliable */ ++ h_path.dentry = h_path.mnt->mnt_root; ++ err = vfs_statfs(&h_path, buf); ++ if (unlikely(err)) ++ goto out; ++ ++ if (bsize > buf->f_bsize) { ++ /* ++ * we will reduce bsize, so we have to expand blocks ++ * etc. to match them again ++ */ ++ factor = (bsize / buf->f_bsize); ++ blocks = au_mul_till_max(blocks, factor); ++ bfree = au_mul_till_max(bfree, factor); ++ bavail = au_mul_till_max(bavail, factor); ++ bsize = buf->f_bsize; ++ } ++ ++ factor = (buf->f_bsize / bsize); ++ blocks = au_add_till_max(blocks, ++ au_mul_till_max(buf->f_blocks, factor)); ++ bfree = au_add_till_max(bfree, ++ au_mul_till_max(buf->f_bfree, factor)); ++ bavail = au_add_till_max(bavail, ++ au_mul_till_max(buf->f_bavail, factor)); ++ files = au_add_till_max(files, buf->f_files); ++ ffree = au_add_till_max(ffree, buf->f_ffree); ++ } ++ ++ buf->f_bsize = bsize; ++ buf->f_blocks = blocks; ++ buf->f_bfree = bfree; ++ buf->f_bavail = bavail; ++ buf->f_files = files; ++ buf->f_ffree = ffree; ++ buf->f_frsize = 0; ++ ++out: ++ return err; ++} ++ ++static int aufs_statfs(struct dentry *dentry, struct kstatfs *buf) ++{ ++ int err; ++ struct path h_path; ++ struct super_block *sb; ++ ++ /* lock free root dinfo */ ++ sb = dentry->d_sb; ++ si_noflush_read_lock(sb); ++ if (!au_opt_test(au_mntflags(sb), SUM)) { ++ /* sb->s_root for NFS is unreliable */ ++ h_path.mnt = au_sbr_mnt(sb, 0); ++ h_path.dentry = h_path.mnt->mnt_root; ++ err = vfs_statfs(&h_path, buf); ++ } else ++ err = au_statfs_sum(sb, buf); ++ si_read_unlock(sb); ++ ++ if (!err) { ++ buf->f_type = AUFS_SUPER_MAGIC; ++ buf->f_namelen = AUFS_MAX_NAMELEN; ++ memset(&buf->f_fsid, 0, sizeof(buf->f_fsid)); ++ } ++ /* buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1; */ ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_sync_fs(struct super_block *sb, int wait) ++{ ++ int err, e; ++ aufs_bindex_t bbot, bindex; ++ struct au_branch *br; ++ struct super_block *h_sb; ++ ++ err = 0; ++ si_noflush_read_lock(sb); ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (!au_br_writable(br->br_perm)) ++ continue; ++ ++ h_sb = au_sbr_sb(sb, bindex); ++ e = vfsub_sync_filesystem(h_sb, wait); ++ if (unlikely(e && !err)) ++ err = e; ++ /* go on even if an error happens */ ++ } ++ si_read_unlock(sb); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* final actions when unmounting a file system */ ++static void aufs_put_super(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = au_sbi(sb); ++ if (sbinfo) ++ kobject_put(&sbinfo->si_kobj); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void *au_array_alloc(unsigned long long *hint, au_arraycb_t cb, ++ struct super_block *sb, void *arg) ++{ ++ void *array; ++ unsigned long long n, sz; ++ ++ array = NULL; ++ n = 0; ++ if (!*hint) ++ goto out; ++ ++ if (*hint > ULLONG_MAX / sizeof(array)) { ++ array = ERR_PTR(-EMFILE); ++ pr_err("hint %llu\n", *hint); ++ goto out; ++ } ++ ++ sz = sizeof(array) * *hint; ++ array = kzalloc(sz, GFP_NOFS); ++ if (unlikely(!array)) ++ array = vzalloc(sz); ++ if (unlikely(!array)) { ++ array = ERR_PTR(-ENOMEM); ++ goto out; ++ } ++ ++ n = cb(sb, array, *hint, arg); ++ AuDebugOn(n > *hint); ++ ++out: ++ *hint = n; ++ return array; ++} ++ ++static unsigned long long au_iarray_cb(struct super_block *sb, void *a, ++ unsigned long long max __maybe_unused, ++ void *arg) ++{ ++ unsigned long long n; ++ struct inode **p, *inode; ++ struct list_head *head; ++ ++ n = 0; ++ p = a; ++ head = arg; ++ spin_lock(&sb->s_inode_list_lock); ++ list_for_each_entry(inode, head, i_sb_list) { ++ if (!au_is_bad_inode(inode) ++ && au_ii(inode)->ii_btop >= 0) { ++ spin_lock(&inode->i_lock); ++ if (atomic_read(&inode->i_count)) { ++ au_igrab(inode); ++ *p++ = inode; ++ n++; ++ AuDebugOn(n > max); ++ } ++ spin_unlock(&inode->i_lock); ++ } ++ } ++ spin_unlock(&sb->s_inode_list_lock); ++ ++ return n; ++} ++ ++struct inode **au_iarray_alloc(struct super_block *sb, unsigned long long *max) ++{ ++ struct au_sbinfo *sbi; ++ ++ sbi = au_sbi(sb); ++ *max = au_lcnt_read(&sbi->si_ninodes, /*do_rev*/1); ++ return au_array_alloc(max, au_iarray_cb, sb, &sb->s_inodes); ++} ++ ++void au_iarray_free(struct inode **a, unsigned long long max) ++{ ++ unsigned long long ull; ++ ++ for (ull = 0; ull < max; ull++) ++ iput(a[ull]); ++ kvfree(a); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * refresh dentry and inode at remount time. ++ */ ++/* todo: consolidate with simple_reval_dpath() and au_reval_for_attr() */ ++static int au_do_refresh(struct dentry *dentry, unsigned int dir_flags, ++ struct dentry *parent) ++{ ++ int err; ++ ++ di_write_lock_child(dentry); ++ di_read_lock_parent(parent, AuLock_IR); ++ err = au_refresh_dentry(dentry, parent); ++ if (!err && dir_flags) ++ au_hn_reset(d_inode(dentry), dir_flags); ++ di_read_unlock(parent, AuLock_IR); ++ di_write_unlock(dentry); ++ ++ return err; ++} ++ ++static int au_do_refresh_d(struct dentry *dentry, unsigned int sigen, ++ struct au_sbinfo *sbinfo, ++ const unsigned int dir_flags, unsigned int do_idop) ++{ ++ int err; ++ struct dentry *parent; ++ ++ err = 0; ++ parent = dget_parent(dentry); ++ if (!au_digen_test(parent, sigen) && au_digen_test(dentry, sigen)) { ++ if (d_really_is_positive(dentry)) { ++ if (!d_is_dir(dentry)) ++ err = au_do_refresh(dentry, /*dir_flags*/0, ++ parent); ++ else { ++ err = au_do_refresh(dentry, dir_flags, parent); ++ if (unlikely(err)) ++ au_fset_si(sbinfo, FAILED_REFRESH_DIR); ++ } ++ } else ++ err = au_do_refresh(dentry, /*dir_flags*/0, parent); ++ AuDbgDentry(dentry); ++ } ++ dput(parent); ++ ++ if (!err) { ++ if (do_idop) ++ au_refresh_dop(dentry, /*force_reval*/0); ++ } else ++ au_refresh_dop(dentry, /*force_reval*/1); ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_refresh_d(struct super_block *sb, unsigned int do_idop) ++{ ++ int err, i, j, ndentry, e; ++ unsigned int sigen; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries, *d; ++ struct au_sbinfo *sbinfo; ++ struct dentry *root = sb->s_root; ++ const unsigned int dir_flags = au_hi_flags(d_inode(root), /*isdir*/1); ++ ++ if (do_idop) ++ au_refresh_dop(root, /*force_reval*/0); ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_dcsub_pages(&dpages, root, NULL, NULL); ++ if (unlikely(err)) ++ goto out_dpages; ++ ++ sigen = au_sigen(sb); ++ sbinfo = au_sbi(sb); ++ for (i = 0; i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ ndentry = dpage->ndentry; ++ for (j = 0; j < ndentry; j++) { ++ d = dentries[j]; ++ e = au_do_refresh_d(d, sigen, sbinfo, dir_flags, ++ do_idop); ++ if (unlikely(e && !err)) ++ err = e; ++ /* go on even err */ ++ } ++ } ++ ++out_dpages: ++ au_dpages_free(&dpages); ++out: ++ return err; ++} ++ ++static int au_refresh_i(struct super_block *sb, unsigned int do_idop) ++{ ++ int err, e; ++ unsigned int sigen; ++ unsigned long long max, ull; ++ struct inode *inode, **array; ++ ++ array = au_iarray_alloc(sb, &max); ++ err = PTR_ERR(array); ++ if (IS_ERR(array)) ++ goto out; ++ ++ err = 0; ++ sigen = au_sigen(sb); ++ for (ull = 0; ull < max; ull++) { ++ inode = array[ull]; ++ if (unlikely(!inode)) ++ break; ++ ++ e = 0; ++ ii_write_lock_child(inode); ++ if (au_iigen(inode, NULL) != sigen) { ++ e = au_refresh_hinode_self(inode); ++ if (unlikely(e)) { ++ au_refresh_iop(inode, /*force_getattr*/1); ++ pr_err("error %d, i%lu\n", e, inode->i_ino); ++ if (!err) ++ err = e; ++ /* go on even if err */ ++ } ++ } ++ if (!e && do_idop) ++ au_refresh_iop(inode, /*force_getattr*/0); ++ ii_write_unlock(inode); ++ } ++ ++ au_iarray_free(array, max); ++ ++out: ++ return err; ++} ++ ++static void au_remount_refresh(struct super_block *sb, unsigned int do_idop) ++{ ++ int err, e; ++ unsigned int udba; ++ aufs_bindex_t bindex, bbot; ++ struct dentry *root; ++ struct inode *inode; ++ struct au_branch *br; ++ struct au_sbinfo *sbi; ++ ++ au_sigen_inc(sb); ++ sbi = au_sbi(sb); ++ au_fclr_si(sbi, FAILED_REFRESH_DIR); ++ ++ root = sb->s_root; ++ DiMustNoWaiters(root); ++ inode = d_inode(root); ++ IiMustNoWaiters(inode); ++ ++ udba = au_opt_udba(sb); ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ err = au_hnotify_reset_br(udba, br, br->br_perm); ++ if (unlikely(err)) ++ AuIOErr("hnotify failed on br %d, %d, ignored\n", ++ bindex, err); ++ /* go on even if err */ ++ } ++ au_hn_reset(inode, au_hi_flags(inode, /*isdir*/1)); ++ ++ if (do_idop) { ++ if (au_ftest_si(sbi, NO_DREVAL)) { ++ AuDebugOn(sb->s_d_op == &aufs_dop_noreval); ++ sb->s_d_op = &aufs_dop_noreval; ++ AuDebugOn(sbi->si_iop_array == aufs_iop_nogetattr); ++ sbi->si_iop_array = aufs_iop_nogetattr; ++ } else { ++ AuDebugOn(sb->s_d_op == &aufs_dop); ++ sb->s_d_op = &aufs_dop; ++ AuDebugOn(sbi->si_iop_array == aufs_iop); ++ sbi->si_iop_array = aufs_iop; ++ } ++ pr_info("reset to %ps and %ps\n", ++ sb->s_d_op, sbi->si_iop_array); ++ } ++ ++ di_write_unlock(root); ++ err = au_refresh_d(sb, do_idop); ++ e = au_refresh_i(sb, do_idop); ++ if (unlikely(e && !err)) ++ err = e; ++ /* aufs_write_lock() calls ..._child() */ ++ di_write_lock_child(root); ++ ++ au_cpup_attr_all(inode, /*force*/1); ++ ++ if (unlikely(err)) ++ AuIOErr("refresh failed, ignored, %d\n", err); ++} ++ ++/* stop extra interpretation of errno in mount(8), and strange error messages */ ++static int cvt_err(int err) ++{ ++ AuTraceErr(err); ++ ++ switch (err) { ++ case -ENOENT: ++ case -ENOTDIR: ++ case -EEXIST: ++ case -EIO: ++ err = -EINVAL; ++ } ++ return err; ++} ++ ++static int aufs_remount_fs(struct super_block *sb, int *flags, char *data) ++{ ++ int err, do_dx; ++ unsigned int mntflags; ++ struct au_opts opts = { ++ .opt = NULL ++ }; ++ struct dentry *root; ++ struct inode *inode; ++ struct au_sbinfo *sbinfo; ++ ++ err = 0; ++ root = sb->s_root; ++ if (!data || !*data) { ++ err = si_write_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (!err) { ++ di_write_lock_child(root); ++ err = au_opts_verify(sb, *flags, /*pending*/0); ++ aufs_write_unlock(root); ++ } ++ goto out; ++ } ++ ++ err = -ENOMEM; ++ opts.opt = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!opts.opt)) ++ goto out; ++ opts.max_opt = PAGE_SIZE / sizeof(*opts.opt); ++ opts.flags = AuOpts_REMOUNT; ++ opts.sb_flags = *flags; ++ ++ /* parse it before aufs lock */ ++ err = au_opts_parse(sb, data, &opts); ++ if (unlikely(err)) ++ goto out_opts; ++ ++ sbinfo = au_sbi(sb); ++ inode = d_inode(root); ++ inode_lock(inode); ++ err = si_write_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (unlikely(err)) ++ goto out_mtx; ++ di_write_lock_child(root); ++ ++ /* au_opts_remount() may return an error */ ++ err = au_opts_remount(sb, &opts); ++ au_opts_free(&opts); ++ ++ if (au_ftest_opts(opts.flags, REFRESH)) ++ au_remount_refresh(sb, au_ftest_opts(opts.flags, REFRESH_IDOP)); ++ ++ if (au_ftest_opts(opts.flags, REFRESH_DYAOP)) { ++ mntflags = au_mntflags(sb); ++ do_dx = !!au_opt_test(mntflags, DIO); ++ au_dy_arefresh(do_dx); ++ } ++ ++ au_fhsm_wrote_all(sb, /*force*/1); /* ?? */ ++ aufs_write_unlock(root); ++ ++out_mtx: ++ inode_unlock(inode); ++out_opts: ++ free_page((unsigned long)opts.opt); ++out: ++ err = cvt_err(err); ++ AuTraceErr(err); ++ return err; ++} ++ ++static const struct super_operations aufs_sop = { ++ .alloc_inode = aufs_alloc_inode, ++ .destroy_inode = aufs_destroy_inode, ++ .free_inode = aufs_free_inode, ++ /* always deleting, no clearing */ ++ .drop_inode = generic_delete_inode, ++ .show_options = aufs_show_options, ++ .statfs = aufs_statfs, ++ .put_super = aufs_put_super, ++ .sync_fs = aufs_sync_fs, ++ .remount_fs = aufs_remount_fs ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int alloc_root(struct super_block *sb) ++{ ++ int err; ++ struct inode *inode; ++ struct dentry *root; ++ ++ err = -ENOMEM; ++ inode = au_iget_locked(sb, AUFS_ROOT_INO); ++ err = PTR_ERR(inode); ++ if (IS_ERR(inode)) ++ goto out; ++ ++ inode->i_op = aufs_iop + AuIop_DIR; /* with getattr by default */ ++ inode->i_fop = &aufs_dir_fop; ++ inode->i_mode = S_IFDIR; ++ set_nlink(inode, 2); ++ unlock_new_inode(inode); ++ ++ root = d_make_root(inode); ++ if (unlikely(!root)) ++ goto out; ++ err = PTR_ERR(root); ++ if (IS_ERR(root)) ++ goto out; ++ ++ err = au_di_init(root); ++ if (!err) { ++ sb->s_root = root; ++ return 0; /* success */ ++ } ++ dput(root); ++ ++out: ++ return err; ++} ++ ++static int aufs_fill_super(struct super_block *sb, void *raw_data, ++ int silent __maybe_unused) ++{ ++ int err; ++ struct au_opts opts = { ++ .opt = NULL ++ }; ++ struct au_sbinfo *sbinfo; ++ struct dentry *root; ++ struct inode *inode; ++ char *arg = raw_data; ++ ++ if (unlikely(!arg || !*arg)) { ++ err = -EINVAL; ++ pr_err("no arg\n"); ++ goto out; ++ } ++ ++ err = -ENOMEM; ++ opts.opt = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!opts.opt)) ++ goto out; ++ opts.max_opt = PAGE_SIZE / sizeof(*opts.opt); ++ opts.sb_flags = sb->s_flags; ++ ++ err = au_si_alloc(sb); ++ if (unlikely(err)) ++ goto out_opts; ++ sbinfo = au_sbi(sb); ++ ++ /* all timestamps always follow the ones on the branch */ ++ sb->s_flags |= SB_NOATIME | SB_NODIRATIME; ++ sb->s_flags |= SB_I_VERSION; /* do we really need this? */ ++ sb->s_op = &aufs_sop; ++ sb->s_d_op = &aufs_dop; ++ sb->s_magic = AUFS_SUPER_MAGIC; ++ sb->s_maxbytes = 0; ++ sb->s_stack_depth = 1; ++ au_export_init(sb); ++ au_xattr_init(sb); ++ ++ err = alloc_root(sb); ++ if (unlikely(err)) { ++ si_write_unlock(sb); ++ goto out_info; ++ } ++ root = sb->s_root; ++ inode = d_inode(root); ++ ++ /* ++ * actually we can parse options regardless aufs lock here. ++ * but at remount time, parsing must be done before aufs lock. ++ * so we follow the same rule. ++ */ ++ ii_write_lock_parent(inode); ++ aufs_write_unlock(root); ++ err = au_opts_parse(sb, arg, &opts); ++ if (unlikely(err)) ++ goto out_root; ++ ++ /* lock vfs_inode first, then aufs. */ ++ inode_lock(inode); ++ aufs_write_lock(root); ++ err = au_opts_mount(sb, &opts); ++ au_opts_free(&opts); ++ if (!err && au_ftest_si(sbinfo, NO_DREVAL)) { ++ sb->s_d_op = &aufs_dop_noreval; ++ pr_info("%ps\n", sb->s_d_op); ++ au_refresh_dop(root, /*force_reval*/0); ++ sbinfo->si_iop_array = aufs_iop_nogetattr; ++ au_refresh_iop(inode, /*force_getattr*/0); ++ } ++ aufs_write_unlock(root); ++ inode_unlock(inode); ++ if (!err) ++ goto out_opts; /* success */ ++ ++out_root: ++ dput(root); ++ sb->s_root = NULL; ++out_info: ++ kobject_put(&sbinfo->si_kobj); ++ sb->s_fs_info = NULL; ++out_opts: ++ free_page((unsigned long)opts.opt); ++out: ++ AuTraceErr(err); ++ err = cvt_err(err); ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry *aufs_mount(struct file_system_type *fs_type, int flags, ++ const char *dev_name __maybe_unused, ++ void *raw_data) ++{ ++ struct dentry *root; ++ ++ /* all timestamps always follow the ones on the branch */ ++ /* mnt->mnt_flags |= MNT_NOATIME | MNT_NODIRATIME; */ ++ root = mount_nodev(fs_type, flags, raw_data, aufs_fill_super); ++ if (IS_ERR(root)) ++ goto out; ++ ++ au_sbilist_add(root->d_sb); ++ ++out: ++ return root; ++} ++ ++static void aufs_kill_sb(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = au_sbi(sb); ++ if (sbinfo) { ++ au_sbilist_del(sb); ++ aufs_write_lock(sb->s_root); ++ au_fhsm_fin(sb); ++ if (sbinfo->si_wbr_create_ops->fin) ++ sbinfo->si_wbr_create_ops->fin(sb); ++ if (au_opt_test(sbinfo->si_mntflags, UDBA_HNOTIFY)) { ++ au_opt_set_udba(sbinfo->si_mntflags, UDBA_NONE); ++ au_remount_refresh(sb, /*do_idop*/0); ++ } ++ if (au_opt_test(sbinfo->si_mntflags, PLINK)) ++ au_plink_put(sb, /*verbose*/1); ++ au_xino_clr(sb); ++ au_dr_opt_flush(sb); ++ sbinfo->si_sb = NULL; ++ aufs_write_unlock(sb->s_root); ++ au_nwt_flush(&sbinfo->si_nowait); ++ } ++ kill_anon_super(sb); ++} ++ ++struct file_system_type aufs_fs_type = { ++ .name = AUFS_FSTYPE, ++ /* a race between rename and others */ ++ .fs_flags = FS_RENAME_DOES_D_MOVE, ++ .mount = aufs_mount, ++ .kill_sb = aufs_kill_sb, ++ /* no need to __module_get() and module_put(). */ ++ .owner = THIS_MODULE, ++}; +diff --git a/fs/aufs/super.h b/fs/aufs/super.h +new file mode 100644 +index 000000000000..37205202c272 +--- /dev/null ++++ b/fs/aufs/super.h +@@ -0,0 +1,576 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * super_block operations ++ */ ++ ++#ifndef __AUFS_SUPER_H__ ++#define __AUFS_SUPER_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++#include "hbl.h" ++#include "lcnt.h" ++#include "rwsem.h" ++#include "wkq.h" ++ ++/* policies to select one among multiple writable branches */ ++struct au_wbr_copyup_operations { ++ int (*copyup)(struct dentry *dentry); ++}; ++ ++#define AuWbr_DIR 1 /* target is a dir */ ++#define AuWbr_PARENT (1 << 1) /* always require a parent */ ++ ++#define au_ftest_wbr(flags, name) ((flags) & AuWbr_##name) ++#define au_fset_wbr(flags, name) { (flags) |= AuWbr_##name; } ++#define au_fclr_wbr(flags, name) { (flags) &= ~AuWbr_##name; } ++ ++struct au_wbr_create_operations { ++ int (*create)(struct dentry *dentry, unsigned int flags); ++ int (*init)(struct super_block *sb); ++ int (*fin)(struct super_block *sb); ++}; ++ ++struct au_wbr_mfs { ++ struct mutex mfs_lock; /* protect this structure */ ++ unsigned long mfs_jiffy; ++ unsigned long mfs_expire; ++ aufs_bindex_t mfs_bindex; ++ ++ unsigned long long mfsrr_bytes; ++ unsigned long long mfsrr_watermark; ++}; ++ ++#define AuPlink_NHASH 100 ++static inline int au_plink_hash(ino_t ino) ++{ ++ return ino % AuPlink_NHASH; ++} ++ ++/* File-based Hierarchical Storage Management */ ++struct au_fhsm { ++#ifdef CONFIG_AUFS_FHSM ++ /* allow only one process who can receive the notification */ ++ spinlock_t fhsm_spin; ++ pid_t fhsm_pid; ++ wait_queue_head_t fhsm_wqh; ++ atomic_t fhsm_readable; ++ ++ /* these are protected by si_rwsem */ ++ unsigned long fhsm_expire; ++ aufs_bindex_t fhsm_bottom; ++#endif ++}; ++ ++struct au_branch; ++struct au_sbinfo { ++ /* nowait tasks in the system-wide workqueue */ ++ struct au_nowait_tasks si_nowait; ++ ++ /* ++ * tried sb->s_umount, but failed due to the dependency between i_mutex. ++ * rwsem for au_sbinfo is necessary. ++ */ ++ struct au_rwsem si_rwsem; ++ ++ /* ++ * dirty approach to protect sb->sb_inodes and ->s_files (gone) from ++ * remount. ++ */ ++ au_lcnt_t si_ninodes, si_nfiles; ++ ++ /* branch management */ ++ unsigned int si_generation; ++ ++ /* see AuSi_ flags */ ++ unsigned char au_si_status; ++ ++ aufs_bindex_t si_bbot; ++ ++ /* dirty trick to keep br_id plus */ ++ unsigned int si_last_br_id : ++ sizeof(aufs_bindex_t) * BITS_PER_BYTE - 1; ++ struct au_branch **si_branch; ++ ++ /* policy to select a writable branch */ ++ unsigned char si_wbr_copyup; ++ unsigned char si_wbr_create; ++ struct au_wbr_copyup_operations *si_wbr_copyup_ops; ++ struct au_wbr_create_operations *si_wbr_create_ops; ++ ++ /* round robin */ ++ atomic_t si_wbr_rr_next; ++ ++ /* most free space */ ++ struct au_wbr_mfs si_wbr_mfs; ++ ++ /* File-based Hierarchical Storage Management */ ++ struct au_fhsm si_fhsm; ++ ++ /* mount flags */ ++ /* include/asm-ia64/siginfo.h defines a macro named si_flags */ ++ unsigned int si_mntflags; ++ ++ /* external inode number (bitmap and translation table) */ ++ vfs_readf_t si_xread; ++ vfs_writef_t si_xwrite; ++ loff_t si_ximaxent; /* max entries in a xino */ ++ ++ struct file *si_xib; ++ struct mutex si_xib_mtx; /* protect xib members */ ++ unsigned long *si_xib_buf; ++ unsigned long si_xib_last_pindex; ++ int si_xib_next_bit; ++ ++ unsigned long si_xino_jiffy; ++ unsigned long si_xino_expire; ++ /* reserved for future use */ ++ /* unsigned long long si_xib_limit; */ /* Max xib file size */ ++ ++#ifdef CONFIG_AUFS_EXPORT ++ /* i_generation */ ++ /* todo: make xigen file an array to support many inode numbers */ ++ struct file *si_xigen; ++ atomic_t si_xigen_next; ++#endif ++ ++ /* dirty trick to support atomic_open */ ++ struct hlist_bl_head si_aopen; ++ ++ /* vdir parameters */ ++ unsigned long si_rdcache; /* max cache time in jiffies */ ++ unsigned int si_rdblk; /* deblk size */ ++ unsigned int si_rdhash; /* hash size */ ++ ++ /* ++ * If the number of whiteouts are larger than si_dirwh, leave all of ++ * them after au_whtmp_ren to reduce the cost of rmdir(2). ++ * future fsck.aufs or kernel thread will remove them later. ++ * Otherwise, remove all whiteouts and the dir in rmdir(2). ++ */ ++ unsigned int si_dirwh; ++ ++ /* pseudo_link list */ ++ struct hlist_bl_head si_plink[AuPlink_NHASH]; ++ wait_queue_head_t si_plink_wq; ++ spinlock_t si_plink_maint_lock; ++ pid_t si_plink_maint_pid; ++ ++ /* file list */ ++ struct hlist_bl_head si_files; ++ ++ /* with/without getattr, brother of sb->s_d_op */ ++ const struct inode_operations *si_iop_array; ++ ++ /* ++ * sysfs and lifetime management. ++ * this is not a small structure and it may be a waste of memory in case ++ * of sysfs is disabled, particularly when many aufs-es are mounted. ++ * but using sysfs is majority. ++ */ ++ struct kobject si_kobj; ++#ifdef CONFIG_DEBUG_FS ++ struct dentry *si_dbgaufs; ++ struct dentry *si_dbgaufs_plink; ++ struct dentry *si_dbgaufs_xib; ++#ifdef CONFIG_AUFS_EXPORT ++ struct dentry *si_dbgaufs_xigen; ++#endif ++#endif ++ ++#ifdef CONFIG_AUFS_SBILIST ++ struct hlist_bl_node si_list; ++#endif ++ ++ /* dirty, necessary for unmounting, sysfs and sysrq */ ++ struct super_block *si_sb; ++}; ++ ++/* sbinfo status flags */ ++/* ++ * set true when refresh_dirs() failed at remount time. ++ * then try refreshing dirs at access time again. ++ * if it is false, refreshing dirs at access time is unnecessary ++ */ ++#define AuSi_FAILED_REFRESH_DIR 1 ++#define AuSi_FHSM (1 << 1) /* fhsm is active now */ ++#define AuSi_NO_DREVAL (1 << 2) /* disable all d_revalidate */ ++ ++#ifndef CONFIG_AUFS_FHSM ++#undef AuSi_FHSM ++#define AuSi_FHSM 0 ++#endif ++ ++static inline unsigned char au_do_ftest_si(struct au_sbinfo *sbi, ++ unsigned int flag) ++{ ++ AuRwMustAnyLock(&sbi->si_rwsem); ++ return sbi->au_si_status & flag; ++} ++#define au_ftest_si(sbinfo, name) au_do_ftest_si(sbinfo, AuSi_##name) ++#define au_fset_si(sbinfo, name) do { \ ++ AuRwMustWriteLock(&(sbinfo)->si_rwsem); \ ++ (sbinfo)->au_si_status |= AuSi_##name; \ ++} while (0) ++#define au_fclr_si(sbinfo, name) do { \ ++ AuRwMustWriteLock(&(sbinfo)->si_rwsem); \ ++ (sbinfo)->au_si_status &= ~AuSi_##name; \ ++} while (0) ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policy to select one among writable branches */ ++#define AuWbrCopyup(sbinfo, ...) \ ++ ((sbinfo)->si_wbr_copyup_ops->copyup(__VA_ARGS__)) ++#define AuWbrCreate(sbinfo, ...) \ ++ ((sbinfo)->si_wbr_create_ops->create(__VA_ARGS__)) ++ ++/* flags for si_read_lock()/aufs_read_lock()/di_read_lock() */ ++#define AuLock_DW 1 /* write-lock dentry */ ++#define AuLock_IR (1 << 1) /* read-lock inode */ ++#define AuLock_IW (1 << 2) /* write-lock inode */ ++#define AuLock_FLUSH (1 << 3) /* wait for 'nowait' tasks */ ++#define AuLock_DIRS (1 << 4) /* target is a pair of dirs */ ++ /* except RENAME_EXCHANGE */ ++#define AuLock_NOPLM (1 << 5) /* return err in plm mode */ ++#define AuLock_NOPLMW (1 << 6) /* wait for plm mode ends */ ++#define AuLock_GEN (1 << 7) /* test digen/iigen */ ++#define au_ftest_lock(flags, name) ((flags) & AuLock_##name) ++#define au_fset_lock(flags, name) \ ++ do { (flags) |= AuLock_##name; } while (0) ++#define au_fclr_lock(flags, name) \ ++ do { (flags) &= ~AuLock_##name; } while (0) ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* super.c */ ++extern struct file_system_type aufs_fs_type; ++struct inode *au_iget_locked(struct super_block *sb, ino_t ino); ++typedef unsigned long long (*au_arraycb_t)(struct super_block *sb, void *array, ++ unsigned long long max, void *arg); ++void *au_array_alloc(unsigned long long *hint, au_arraycb_t cb, ++ struct super_block *sb, void *arg); ++struct inode **au_iarray_alloc(struct super_block *sb, unsigned long long *max); ++void au_iarray_free(struct inode **a, unsigned long long max); ++ ++/* sbinfo.c */ ++void au_si_free(struct kobject *kobj); ++int au_si_alloc(struct super_block *sb); ++int au_sbr_realloc(struct au_sbinfo *sbinfo, int nbr, int may_shrink); ++ ++unsigned int au_sigen_inc(struct super_block *sb); ++aufs_bindex_t au_new_br_id(struct super_block *sb); ++ ++int si_read_lock(struct super_block *sb, int flags); ++int si_write_lock(struct super_block *sb, int flags); ++int aufs_read_lock(struct dentry *dentry, int flags); ++void aufs_read_unlock(struct dentry *dentry, int flags); ++void aufs_write_lock(struct dentry *dentry); ++void aufs_write_unlock(struct dentry *dentry); ++int aufs_read_and_write_lock2(struct dentry *d1, struct dentry *d2, int flags); ++void aufs_read_and_write_unlock2(struct dentry *d1, struct dentry *d2); ++ ++/* wbr_policy.c */ ++extern struct au_wbr_copyup_operations au_wbr_copyup_ops[]; ++extern struct au_wbr_create_operations au_wbr_create_ops[]; ++int au_cpdown_dirs(struct dentry *dentry, aufs_bindex_t bdst); ++int au_wbr_nonopq(struct dentry *dentry, aufs_bindex_t bindex); ++int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t btop); ++ ++/* mvdown.c */ ++int au_mvdown(struct dentry *dentry, struct aufs_mvdown __user *arg); ++ ++#ifdef CONFIG_AUFS_FHSM ++/* fhsm.c */ ++ ++static inline pid_t au_fhsm_pid(struct au_fhsm *fhsm) ++{ ++ pid_t pid; ++ ++ spin_lock(&fhsm->fhsm_spin); ++ pid = fhsm->fhsm_pid; ++ spin_unlock(&fhsm->fhsm_spin); ++ ++ return pid; ++} ++ ++void au_fhsm_wrote(struct super_block *sb, aufs_bindex_t bindex, int force); ++void au_fhsm_wrote_all(struct super_block *sb, int force); ++int au_fhsm_fd(struct super_block *sb, int oflags); ++int au_fhsm_br_alloc(struct au_branch *br); ++void au_fhsm_set_bottom(struct super_block *sb, aufs_bindex_t bindex); ++void au_fhsm_fin(struct super_block *sb); ++void au_fhsm_init(struct au_sbinfo *sbinfo); ++void au_fhsm_set(struct au_sbinfo *sbinfo, unsigned int sec); ++void au_fhsm_show(struct seq_file *seq, struct au_sbinfo *sbinfo); ++#else ++AuStubVoid(au_fhsm_wrote, struct super_block *sb, aufs_bindex_t bindex, ++ int force) ++AuStubVoid(au_fhsm_wrote_all, struct super_block *sb, int force) ++AuStub(int, au_fhsm_fd, return -EOPNOTSUPP, struct super_block *sb, int oflags) ++AuStub(pid_t, au_fhsm_pid, return 0, struct au_fhsm *fhsm) ++AuStubInt0(au_fhsm_br_alloc, struct au_branch *br) ++AuStubVoid(au_fhsm_set_bottom, struct super_block *sb, aufs_bindex_t bindex) ++AuStubVoid(au_fhsm_fin, struct super_block *sb) ++AuStubVoid(au_fhsm_init, struct au_sbinfo *sbinfo) ++AuStubVoid(au_fhsm_set, struct au_sbinfo *sbinfo, unsigned int sec) ++AuStubVoid(au_fhsm_show, struct seq_file *seq, struct au_sbinfo *sbinfo) ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_sbinfo *au_sbi(struct super_block *sb) ++{ ++ return sb->s_fs_info; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_EXPORT ++int au_test_nfsd(void); ++void au_export_init(struct super_block *sb); ++void au_xigen_inc(struct inode *inode); ++int au_xigen_new(struct inode *inode); ++int au_xigen_set(struct super_block *sb, struct path *path); ++void au_xigen_clr(struct super_block *sb); ++ ++static inline int au_busy_or_stale(void) ++{ ++ if (!au_test_nfsd()) ++ return -EBUSY; ++ return -ESTALE; ++} ++#else ++AuStubInt0(au_test_nfsd, void) ++AuStubVoid(au_export_init, struct super_block *sb) ++AuStubVoid(au_xigen_inc, struct inode *inode) ++AuStubInt0(au_xigen_new, struct inode *inode) ++AuStubInt0(au_xigen_set, struct super_block *sb, struct path *path) ++AuStubVoid(au_xigen_clr, struct super_block *sb) ++AuStub(int, au_busy_or_stale, return -EBUSY, void) ++#endif /* CONFIG_AUFS_EXPORT */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_SBILIST ++/* module.c */ ++extern struct hlist_bl_head au_sbilist; ++ ++static inline void au_sbilist_init(void) ++{ ++ INIT_HLIST_BL_HEAD(&au_sbilist); ++} ++ ++static inline void au_sbilist_add(struct super_block *sb) ++{ ++ au_hbl_add(&au_sbi(sb)->si_list, &au_sbilist); ++} ++ ++static inline void au_sbilist_del(struct super_block *sb) ++{ ++ au_hbl_del(&au_sbi(sb)->si_list, &au_sbilist); ++} ++ ++#ifdef CONFIG_AUFS_MAGIC_SYSRQ ++static inline void au_sbilist_lock(void) ++{ ++ hlist_bl_lock(&au_sbilist); ++} ++ ++static inline void au_sbilist_unlock(void) ++{ ++ hlist_bl_unlock(&au_sbilist); ++} ++#define AuGFP_SBILIST GFP_ATOMIC ++#else ++AuStubVoid(au_sbilist_lock, void) ++AuStubVoid(au_sbilist_unlock, void) ++#define AuGFP_SBILIST GFP_NOFS ++#endif /* CONFIG_AUFS_MAGIC_SYSRQ */ ++#else ++AuStubVoid(au_sbilist_init, void) ++AuStubVoid(au_sbilist_add, struct super_block *sb) ++AuStubVoid(au_sbilist_del, struct super_block *sb) ++AuStubVoid(au_sbilist_lock, void) ++AuStubVoid(au_sbilist_unlock, void) ++#define AuGFP_SBILIST GFP_NOFS ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline void dbgaufs_si_null(struct au_sbinfo *sbinfo) ++{ ++ /* ++ * This function is a dynamic '__init' function actually, ++ * so the tiny check for si_rwsem is unnecessary. ++ */ ++ /* AuRwMustWriteLock(&sbinfo->si_rwsem); */ ++#ifdef CONFIG_DEBUG_FS ++ sbinfo->si_dbgaufs = NULL; ++ sbinfo->si_dbgaufs_plink = NULL; ++ sbinfo->si_dbgaufs_xib = NULL; ++#ifdef CONFIG_AUFS_EXPORT ++ sbinfo->si_dbgaufs_xigen = NULL; ++#endif ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* current->atomic_flags */ ++/* this value should never corrupt the ones defined in linux/sched.h */ ++#define PFA_AUFS 0x10 ++ ++TASK_PFA_TEST(AUFS, test_aufs) /* task_test_aufs */ ++TASK_PFA_SET(AUFS, aufs) /* task_set_aufs */ ++TASK_PFA_CLEAR(AUFS, aufs) /* task_clear_aufs */ ++ ++static inline int si_pid_test(struct super_block *sb) ++{ ++ return !!task_test_aufs(current); ++} ++ ++static inline void si_pid_clr(struct super_block *sb) ++{ ++ AuDebugOn(!task_test_aufs(current)); ++ task_clear_aufs(current); ++} ++ ++static inline void si_pid_set(struct super_block *sb) ++{ ++ AuDebugOn(task_test_aufs(current)); ++ task_set_aufs(current); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock superblock. mainly for entry point functions */ ++#define __si_read_lock(sb) au_rw_read_lock(&au_sbi(sb)->si_rwsem) ++#define __si_write_lock(sb) au_rw_write_lock(&au_sbi(sb)->si_rwsem) ++#define __si_read_trylock(sb) au_rw_read_trylock(&au_sbi(sb)->si_rwsem) ++#define __si_write_trylock(sb) au_rw_write_trylock(&au_sbi(sb)->si_rwsem) ++/* ++#define __si_read_trylock_nested(sb) \ ++ au_rw_read_trylock_nested(&au_sbi(sb)->si_rwsem) ++#define __si_write_trylock_nested(sb) \ ++ au_rw_write_trylock_nested(&au_sbi(sb)->si_rwsem) ++*/ ++ ++#define __si_read_unlock(sb) au_rw_read_unlock(&au_sbi(sb)->si_rwsem) ++#define __si_write_unlock(sb) au_rw_write_unlock(&au_sbi(sb)->si_rwsem) ++#define __si_downgrade_lock(sb) au_rw_dgrade_lock(&au_sbi(sb)->si_rwsem) ++ ++#define SiMustNoWaiters(sb) AuRwMustNoWaiters(&au_sbi(sb)->si_rwsem) ++#define SiMustAnyLock(sb) AuRwMustAnyLock(&au_sbi(sb)->si_rwsem) ++#define SiMustWriteLock(sb) AuRwMustWriteLock(&au_sbi(sb)->si_rwsem) ++ ++static inline void si_noflush_read_lock(struct super_block *sb) ++{ ++ __si_read_lock(sb); ++ si_pid_set(sb); ++} ++ ++static inline int si_noflush_read_trylock(struct super_block *sb) ++{ ++ int locked; ++ ++ locked = __si_read_trylock(sb); ++ if (locked) ++ si_pid_set(sb); ++ return locked; ++} ++ ++static inline void si_noflush_write_lock(struct super_block *sb) ++{ ++ __si_write_lock(sb); ++ si_pid_set(sb); ++} ++ ++static inline int si_noflush_write_trylock(struct super_block *sb) ++{ ++ int locked; ++ ++ locked = __si_write_trylock(sb); ++ if (locked) ++ si_pid_set(sb); ++ return locked; ++} ++ ++#if 0 /* reserved */ ++static inline int si_read_trylock(struct super_block *sb, int flags) ++{ ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ return si_noflush_read_trylock(sb); ++} ++#endif ++ ++static inline void si_read_unlock(struct super_block *sb) ++{ ++ si_pid_clr(sb); ++ __si_read_unlock(sb); ++} ++ ++#if 0 /* reserved */ ++static inline int si_write_trylock(struct super_block *sb, int flags) ++{ ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ return si_noflush_write_trylock(sb); ++} ++#endif ++ ++static inline void si_write_unlock(struct super_block *sb) ++{ ++ si_pid_clr(sb); ++ __si_write_unlock(sb); ++} ++ ++#if 0 /* reserved */ ++static inline void si_downgrade_lock(struct super_block *sb) ++{ ++ __si_downgrade_lock(sb); ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline aufs_bindex_t au_sbbot(struct super_block *sb) ++{ ++ SiMustAnyLock(sb); ++ return au_sbi(sb)->si_bbot; ++} ++ ++static inline unsigned int au_mntflags(struct super_block *sb) ++{ ++ SiMustAnyLock(sb); ++ return au_sbi(sb)->si_mntflags; ++} ++ ++static inline unsigned int au_sigen(struct super_block *sb) ++{ ++ SiMustAnyLock(sb); ++ return au_sbi(sb)->si_generation; ++} ++ ++static inline struct au_branch *au_sbr(struct super_block *sb, ++ aufs_bindex_t bindex) ++{ ++ SiMustAnyLock(sb); ++ return au_sbi(sb)->si_branch[0 + bindex]; ++} ++ ++static inline loff_t au_xi_maxent(struct super_block *sb) ++{ ++ SiMustAnyLock(sb); ++ return au_sbi(sb)->si_ximaxent; ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_SUPER_H__ */ +diff --git a/fs/aufs/sysaufs.c b/fs/aufs/sysaufs.c +new file mode 100644 +index 000000000000..88d64b34555e +--- /dev/null ++++ b/fs/aufs/sysaufs.c +@@ -0,0 +1,80 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * sysfs interface and lifetime management ++ * they are necessary regardless sysfs is disabled. ++ */ ++ ++#include ++#include "aufs.h" ++ ++unsigned long sysaufs_si_mask; ++struct kset *sysaufs_kset; ++ ++#define AuSiAttr(_name) { \ ++ .attr = { .name = __stringify(_name), .mode = 0444 }, \ ++ .show = sysaufs_si_##_name, \ ++} ++ ++static struct sysaufs_si_attr sysaufs_si_attr_xi_path = AuSiAttr(xi_path); ++struct attribute *sysaufs_si_attrs[] = { ++ &sysaufs_si_attr_xi_path.attr, ++ NULL, ++}; ++ ++static const struct sysfs_ops au_sbi_ops = { ++ .show = sysaufs_si_show ++}; ++ ++static struct kobj_type au_sbi_ktype = { ++ .release = au_si_free, ++ .sysfs_ops = &au_sbi_ops, ++ .default_attrs = sysaufs_si_attrs ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++int sysaufs_si_init(struct au_sbinfo *sbinfo) ++{ ++ int err; ++ ++ sbinfo->si_kobj.kset = sysaufs_kset; ++ /* cf. sysaufs_name() */ ++ err = kobject_init_and_add ++ (&sbinfo->si_kobj, &au_sbi_ktype, /*&sysaufs_kset->kobj*/NULL, ++ SysaufsSiNamePrefix "%lx", sysaufs_si_id(sbinfo)); ++ ++ return err; ++} ++ ++void sysaufs_fin(void) ++{ ++ sysfs_remove_group(&sysaufs_kset->kobj, sysaufs_attr_group); ++ kset_unregister(sysaufs_kset); ++} ++ ++int __init sysaufs_init(void) ++{ ++ int err; ++ ++ do { ++ get_random_bytes(&sysaufs_si_mask, sizeof(sysaufs_si_mask)); ++ } while (!sysaufs_si_mask); ++ ++ err = -EINVAL; ++ sysaufs_kset = kset_create_and_add(AUFS_NAME, NULL, fs_kobj); ++ if (unlikely(!sysaufs_kset)) ++ goto out; ++ err = PTR_ERR(sysaufs_kset); ++ if (IS_ERR(sysaufs_kset)) ++ goto out; ++ err = sysfs_create_group(&sysaufs_kset->kobj, sysaufs_attr_group); ++ if (unlikely(err)) ++ kset_unregister(sysaufs_kset); ++ ++out: ++ return err; ++} +diff --git a/fs/aufs/sysaufs.h b/fs/aufs/sysaufs.h +new file mode 100644 +index 000000000000..0d14752482cf +--- /dev/null ++++ b/fs/aufs/sysaufs.h +@@ -0,0 +1,89 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * sysfs interface and mount lifetime management ++ */ ++ ++#ifndef __SYSAUFS_H__ ++#define __SYSAUFS_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include "module.h" ++ ++struct super_block; ++struct au_sbinfo; ++ ++struct sysaufs_si_attr { ++ struct attribute attr; ++ int (*show)(struct seq_file *seq, struct super_block *sb); ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* sysaufs.c */ ++extern unsigned long sysaufs_si_mask; ++extern struct kset *sysaufs_kset; ++extern struct attribute *sysaufs_si_attrs[]; ++int sysaufs_si_init(struct au_sbinfo *sbinfo); ++int __init sysaufs_init(void); ++void sysaufs_fin(void); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* some people doesn't like to show a pointer in kernel */ ++static inline unsigned long sysaufs_si_id(struct au_sbinfo *sbinfo) ++{ ++ return sysaufs_si_mask ^ (unsigned long)sbinfo; ++} ++ ++#define SysaufsSiNamePrefix "si_" ++#define SysaufsSiNameLen (sizeof(SysaufsSiNamePrefix) + 16) ++static inline void sysaufs_name(struct au_sbinfo *sbinfo, char *name) ++{ ++ snprintf(name, SysaufsSiNameLen, SysaufsSiNamePrefix "%lx", ++ sysaufs_si_id(sbinfo)); ++} ++ ++struct au_branch; ++#ifdef CONFIG_SYSFS ++/* sysfs.c */ ++extern struct attribute_group *sysaufs_attr_group; ++ ++int sysaufs_si_xi_path(struct seq_file *seq, struct super_block *sb); ++ssize_t sysaufs_si_show(struct kobject *kobj, struct attribute *attr, ++ char *buf); ++long au_brinfo_ioctl(struct file *file, unsigned long arg); ++#ifdef CONFIG_COMPAT ++long au_brinfo_compat_ioctl(struct file *file, unsigned long arg); ++#endif ++ ++void sysaufs_br_init(struct au_branch *br); ++void sysaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex); ++void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex); ++ ++#define sysaufs_brs_init() do {} while (0) ++ ++#else ++#define sysaufs_attr_group NULL ++ ++AuStubInt0(sysaufs_si_xi_path, struct seq_file *seq, struct super_block *sb) ++AuStub(ssize_t, sysaufs_si_show, return 0, struct kobject *kobj, ++ struct attribute *attr, char *buf) ++AuStubVoid(sysaufs_br_init, struct au_branch *br) ++AuStubVoid(sysaufs_brs_add, struct super_block *sb, aufs_bindex_t bindex) ++AuStubVoid(sysaufs_brs_del, struct super_block *sb, aufs_bindex_t bindex) ++ ++static inline void sysaufs_brs_init(void) ++{ ++ sysaufs_brs = 0; ++} ++ ++#endif /* CONFIG_SYSFS */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __SYSAUFS_H__ */ +diff --git a/fs/aufs/sysfs.c b/fs/aufs/sysfs.c +new file mode 100644 +index 000000000000..955ed071a12a +--- /dev/null ++++ b/fs/aufs/sysfs.c +@@ -0,0 +1,338 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * sysfs interface ++ */ ++ ++#include ++#include ++#include "aufs.h" ++ ++static struct attribute *au_attr[] = { ++ NULL, /* need to NULL terminate the list of attributes */ ++}; ++ ++static struct attribute_group sysaufs_attr_group_body = { ++ .attrs = au_attr ++}; ++ ++struct attribute_group *sysaufs_attr_group = &sysaufs_attr_group_body; ++ ++/* ---------------------------------------------------------------------- */ ++ ++int sysaufs_si_xi_path(struct seq_file *seq, struct super_block *sb) ++{ ++ int err; ++ ++ SiMustAnyLock(sb); ++ ++ err = 0; ++ if (au_opt_test(au_mntflags(sb), XINO)) { ++ err = au_xino_path(seq, au_sbi(sb)->si_xib); ++ seq_putc(seq, '\n'); ++ } ++ return err; ++} ++ ++/* ++ * the lifetime of branch is independent from the entry under sysfs. ++ * sysfs handles the lifetime of the entry, and never call ->show() after it is ++ * unlinked. ++ */ ++static int sysaufs_si_br(struct seq_file *seq, struct super_block *sb, ++ aufs_bindex_t bindex, int idx) ++{ ++ int err; ++ struct path path; ++ struct dentry *root; ++ struct au_branch *br; ++ au_br_perm_str_t perm; ++ ++ AuDbg("b%d\n", bindex); ++ ++ err = 0; ++ root = sb->s_root; ++ di_read_lock_parent(root, !AuLock_IR); ++ br = au_sbr(sb, bindex); ++ ++ switch (idx) { ++ case AuBrSysfs_BR: ++ path.mnt = au_br_mnt(br); ++ path.dentry = au_h_dptr(root, bindex); ++ err = au_seq_path(seq, &path); ++ if (!err) { ++ au_optstr_br_perm(&perm, br->br_perm); ++ seq_printf(seq, "=%s\n", perm.a); ++ } ++ break; ++ case AuBrSysfs_BRID: ++ seq_printf(seq, "%d\n", br->br_id); ++ break; ++ } ++ di_read_unlock(root, !AuLock_IR); ++ if (unlikely(err || seq_has_overflowed(seq))) ++ err = -E2BIG; ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct seq_file *au_seq(char *p, ssize_t len) ++{ ++ struct seq_file *seq; ++ ++ seq = kzalloc(sizeof(*seq), GFP_NOFS); ++ if (seq) { ++ /* mutex_init(&seq.lock); */ ++ seq->buf = p; ++ seq->size = len; ++ return seq; /* success */ ++ } ++ ++ seq = ERR_PTR(-ENOMEM); ++ return seq; ++} ++ ++#define SysaufsBr_PREFIX "br" ++#define SysaufsBrid_PREFIX "brid" ++ ++/* todo: file size may exceed PAGE_SIZE */ ++ssize_t sysaufs_si_show(struct kobject *kobj, struct attribute *attr, ++ char *buf) ++{ ++ ssize_t err; ++ int idx; ++ long l; ++ aufs_bindex_t bbot; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ struct seq_file *seq; ++ char *name; ++ struct attribute **cattr; ++ ++ sbinfo = container_of(kobj, struct au_sbinfo, si_kobj); ++ sb = sbinfo->si_sb; ++ ++ /* ++ * prevent a race condition between sysfs and aufs. ++ * for instance, sysfs_file_read() calls sysfs_get_active_two() which ++ * prohibits maintaining the sysfs entries. ++ * hew we acquire read lock after sysfs_get_active_two(). ++ * on the other hand, the remount process may maintain the sysfs/aufs ++ * entries after acquiring write lock. ++ * it can cause a deadlock. ++ * simply we gave up processing read here. ++ */ ++ err = -EBUSY; ++ if (unlikely(!si_noflush_read_trylock(sb))) ++ goto out; ++ ++ seq = au_seq(buf, PAGE_SIZE); ++ err = PTR_ERR(seq); ++ if (IS_ERR(seq)) ++ goto out_unlock; ++ ++ name = (void *)attr->name; ++ cattr = sysaufs_si_attrs; ++ while (*cattr) { ++ if (!strcmp(name, (*cattr)->name)) { ++ err = container_of(*cattr, struct sysaufs_si_attr, attr) ++ ->show(seq, sb); ++ goto out_seq; ++ } ++ cattr++; ++ } ++ ++ if (!strncmp(name, SysaufsBrid_PREFIX, ++ sizeof(SysaufsBrid_PREFIX) - 1)) { ++ idx = AuBrSysfs_BRID; ++ name += sizeof(SysaufsBrid_PREFIX) - 1; ++ } else if (!strncmp(name, SysaufsBr_PREFIX, ++ sizeof(SysaufsBr_PREFIX) - 1)) { ++ idx = AuBrSysfs_BR; ++ name += sizeof(SysaufsBr_PREFIX) - 1; ++ } else ++ BUG(); ++ ++ err = kstrtol(name, 10, &l); ++ if (!err) { ++ bbot = au_sbbot(sb); ++ if (l <= bbot) ++ err = sysaufs_si_br(seq, sb, (aufs_bindex_t)l, idx); ++ else ++ err = -ENOENT; ++ } ++ ++out_seq: ++ if (!err) { ++ err = seq->count; ++ /* sysfs limit */ ++ if (unlikely(err == PAGE_SIZE)) ++ err = -EFBIG; ++ } ++ au_kfree_rcu(seq); ++out_unlock: ++ si_read_unlock(sb); ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_brinfo(struct super_block *sb, union aufs_brinfo __user *arg) ++{ ++ int err; ++ int16_t brid; ++ aufs_bindex_t bindex, bbot; ++ size_t sz; ++ char *buf; ++ struct seq_file *seq; ++ struct au_branch *br; ++ ++ si_read_lock(sb, AuLock_FLUSH); ++ bbot = au_sbbot(sb); ++ err = bbot + 1; ++ if (!arg) ++ goto out; ++ ++ err = -ENOMEM; ++ buf = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!buf)) ++ goto out; ++ ++ seq = au_seq(buf, PAGE_SIZE); ++ err = PTR_ERR(seq); ++ if (IS_ERR(seq)) ++ goto out_buf; ++ ++ sz = sizeof(*arg) - offsetof(union aufs_brinfo, path); ++ for (bindex = 0; bindex <= bbot; bindex++, arg++) { ++ /* VERIFY_WRITE */ ++ err = !access_ok(arg, sizeof(*arg)); ++ if (unlikely(err)) ++ break; ++ ++ br = au_sbr(sb, bindex); ++ brid = br->br_id; ++ BUILD_BUG_ON(sizeof(brid) != sizeof(arg->id)); ++ err = __put_user(brid, &arg->id); ++ if (unlikely(err)) ++ break; ++ ++ BUILD_BUG_ON(sizeof(br->br_perm) != sizeof(arg->perm)); ++ err = __put_user(br->br_perm, &arg->perm); ++ if (unlikely(err)) ++ break; ++ ++ err = au_seq_path(seq, &br->br_path); ++ if (unlikely(err)) ++ break; ++ seq_putc(seq, '\0'); ++ if (!seq_has_overflowed(seq)) { ++ err = copy_to_user(arg->path, seq->buf, seq->count); ++ seq->count = 0; ++ if (unlikely(err)) ++ break; ++ } else { ++ err = -E2BIG; ++ goto out_seq; ++ } ++ } ++ if (unlikely(err)) ++ err = -EFAULT; ++ ++out_seq: ++ au_kfree_rcu(seq); ++out_buf: ++ free_page((unsigned long)buf); ++out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++long au_brinfo_ioctl(struct file *file, unsigned long arg) ++{ ++ return au_brinfo(file->f_path.dentry->d_sb, (void __user *)arg); ++} ++ ++#ifdef CONFIG_COMPAT ++long au_brinfo_compat_ioctl(struct file *file, unsigned long arg) ++{ ++ return au_brinfo(file->f_path.dentry->d_sb, compat_ptr(arg)); ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++void sysaufs_br_init(struct au_branch *br) ++{ ++ int i; ++ struct au_brsysfs *br_sysfs; ++ struct attribute *attr; ++ ++ br_sysfs = br->br_sysfs; ++ for (i = 0; i < ARRAY_SIZE(br->br_sysfs); i++) { ++ attr = &br_sysfs->attr; ++ sysfs_attr_init(attr); ++ attr->name = br_sysfs->name; ++ attr->mode = 0444; ++ br_sysfs++; ++ } ++} ++ ++void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ struct au_branch *br; ++ struct kobject *kobj; ++ struct au_brsysfs *br_sysfs; ++ int i; ++ aufs_bindex_t bbot; ++ ++ if (!sysaufs_brs) ++ return; ++ ++ kobj = &au_sbi(sb)->si_kobj; ++ bbot = au_sbbot(sb); ++ for (; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ br_sysfs = br->br_sysfs; ++ for (i = 0; i < ARRAY_SIZE(br->br_sysfs); i++) { ++ sysfs_remove_file(kobj, &br_sysfs->attr); ++ br_sysfs++; ++ } ++ } ++} ++ ++void sysaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ int err, i; ++ aufs_bindex_t bbot; ++ struct kobject *kobj; ++ struct au_branch *br; ++ struct au_brsysfs *br_sysfs; ++ ++ if (!sysaufs_brs) ++ return; ++ ++ kobj = &au_sbi(sb)->si_kobj; ++ bbot = au_sbbot(sb); ++ for (; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ br_sysfs = br->br_sysfs; ++ snprintf(br_sysfs[AuBrSysfs_BR].name, sizeof(br_sysfs->name), ++ SysaufsBr_PREFIX "%d", bindex); ++ snprintf(br_sysfs[AuBrSysfs_BRID].name, sizeof(br_sysfs->name), ++ SysaufsBrid_PREFIX "%d", bindex); ++ for (i = 0; i < ARRAY_SIZE(br->br_sysfs); i++) { ++ err = sysfs_create_file(kobj, &br_sysfs->attr); ++ if (unlikely(err)) ++ pr_warn("failed %s under sysfs(%d)\n", ++ br_sysfs->name, err); ++ br_sysfs++; ++ } ++ } ++} +diff --git a/fs/aufs/sysrq.c b/fs/aufs/sysrq.c +new file mode 100644 +index 000000000000..d51b95163e24 +--- /dev/null ++++ b/fs/aufs/sysrq.c +@@ -0,0 +1,136 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * magic sysrq handler ++ */ ++ ++/* #include */ ++#include ++#include "aufs.h" ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void sysrq_sb(struct super_block *sb) ++{ ++ char *plevel; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ struct hlist_bl_head *files; ++ struct hlist_bl_node *pos; ++ struct au_finfo *finfo; ++ struct inode *i; ++ ++ plevel = au_plevel; ++ au_plevel = KERN_WARNING; ++ ++ /* since we define pr_fmt, call printk directly */ ++#define pr(str) printk(KERN_WARNING AUFS_NAME ": " str) ++ ++ sbinfo = au_sbi(sb); ++ printk(KERN_WARNING "si=%lx\n", sysaufs_si_id(sbinfo)); ++ pr("superblock\n"); ++ au_dpri_sb(sb); ++ ++#if 0 /* reserved */ ++ do { ++ int err, i, j, ndentry; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ ++ err = au_dpages_init(&dpages, GFP_ATOMIC); ++ if (unlikely(err)) ++ break; ++ err = au_dcsub_pages(&dpages, sb->s_root, NULL, NULL); ++ if (!err) ++ for (i = 0; i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ ndentry = dpage->ndentry; ++ for (j = 0; j < ndentry; j++) ++ au_dpri_dentry(dpage->dentries[j]); ++ } ++ au_dpages_free(&dpages); ++ } while (0); ++#endif ++ ++ pr("isolated inode\n"); ++ spin_lock(&sb->s_inode_list_lock); ++ list_for_each_entry(i, &sb->s_inodes, i_sb_list) { ++ spin_lock(&i->i_lock); ++ if (hlist_empty(&i->i_dentry)) ++ au_dpri_inode(i); ++ spin_unlock(&i->i_lock); ++ } ++ spin_unlock(&sb->s_inode_list_lock); ++ ++ pr("files\n"); ++ files = &au_sbi(sb)->si_files; ++ hlist_bl_lock(files); ++ hlist_bl_for_each_entry(finfo, pos, files, fi_hlist) { ++ umode_t mode; ++ ++ file = finfo->fi_file; ++ mode = file_inode(file)->i_mode; ++ if (!special_file(mode)) ++ au_dpri_file(file); ++ } ++ hlist_bl_unlock(files); ++ pr("done\n"); ++ ++#undef pr ++ au_plevel = plevel; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* module parameter */ ++static char *aufs_sysrq_key = "a"; ++module_param_named(sysrq, aufs_sysrq_key, charp, 0444); ++MODULE_PARM_DESC(sysrq, "MagicSysRq key for " AUFS_NAME); ++ ++static void au_sysrq(int key __maybe_unused) ++{ ++ struct au_sbinfo *sbinfo; ++ struct hlist_bl_node *pos; ++ ++ lockdep_off(); ++ au_sbilist_lock(); ++ hlist_bl_for_each_entry(sbinfo, pos, &au_sbilist, si_list) ++ sysrq_sb(sbinfo->si_sb); ++ au_sbilist_unlock(); ++ lockdep_on(); ++} ++ ++static struct sysrq_key_op au_sysrq_op = { ++ .handler = au_sysrq, ++ .help_msg = "Aufs", ++ .action_msg = "Aufs", ++ .enable_mask = SYSRQ_ENABLE_DUMP ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++int __init au_sysrq_init(void) ++{ ++ int err; ++ char key; ++ ++ err = -1; ++ key = *aufs_sysrq_key; ++ if ('a' <= key && key <= 'z') ++ err = register_sysrq_key(key, &au_sysrq_op); ++ if (unlikely(err)) ++ pr_err("err %d, sysrq=%c\n", err, key); ++ return err; ++} ++ ++void au_sysrq_fin(void) ++{ ++ int err; ++ ++ err = unregister_sysrq_key(*aufs_sysrq_key, &au_sysrq_op); ++ if (unlikely(err)) ++ pr_err("err %d (ignored)\n", err); ++} +diff --git a/fs/aufs/vdir.c b/fs/aufs/vdir.c +new file mode 100644 +index 000000000000..6cc7ecf0b0e1 +--- /dev/null ++++ b/fs/aufs/vdir.c +@@ -0,0 +1,883 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * virtual or vertical directory ++ */ ++ ++#include ++#include "aufs.h" ++ ++static unsigned int calc_size(int nlen) ++{ ++ return ALIGN(sizeof(struct au_vdir_de) + nlen, sizeof(ino_t)); ++} ++ ++static int set_deblk_end(union au_vdir_deblk_p *p, ++ union au_vdir_deblk_p *deblk_end) ++{ ++ if (calc_size(0) <= deblk_end->deblk - p->deblk) { ++ p->de->de_str.len = 0; ++ /* smp_mb(); */ ++ return 0; ++ } ++ return -1; /* error */ ++} ++ ++/* returns true or false */ ++static int is_deblk_end(union au_vdir_deblk_p *p, ++ union au_vdir_deblk_p *deblk_end) ++{ ++ if (calc_size(0) <= deblk_end->deblk - p->deblk) ++ return !p->de->de_str.len; ++ return 1; ++} ++ ++static unsigned char *last_deblk(struct au_vdir *vdir) ++{ ++ return vdir->vd_deblk[vdir->vd_nblk - 1]; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* estimate the appropriate size for name hash table */ ++unsigned int au_rdhash_est(loff_t sz) ++{ ++ unsigned int n; ++ ++ n = UINT_MAX; ++ sz >>= 10; ++ if (sz < n) ++ n = sz; ++ if (sz < AUFS_RDHASH_DEF) ++ n = AUFS_RDHASH_DEF; ++ /* pr_info("n %u\n", n); */ ++ return n; ++} ++ ++/* ++ * the allocated memory has to be freed by ++ * au_nhash_wh_free() or au_nhash_de_free(). ++ */ ++int au_nhash_alloc(struct au_nhash *nhash, unsigned int num_hash, gfp_t gfp) ++{ ++ struct hlist_head *head; ++ unsigned int u; ++ size_t sz; ++ ++ sz = sizeof(*nhash->nh_head) * num_hash; ++ head = kmalloc(sz, gfp); ++ if (head) { ++ nhash->nh_num = num_hash; ++ nhash->nh_head = head; ++ for (u = 0; u < num_hash; u++) ++ INIT_HLIST_HEAD(head++); ++ return 0; /* success */ ++ } ++ ++ return -ENOMEM; ++} ++ ++static void nhash_count(struct hlist_head *head) ++{ ++#if 0 /* debugging */ ++ unsigned long n; ++ struct hlist_node *pos; ++ ++ n = 0; ++ hlist_for_each(pos, head) ++ n++; ++ pr_info("%lu\n", n); ++#endif ++} ++ ++static void au_nhash_wh_do_free(struct hlist_head *head) ++{ ++ struct au_vdir_wh *pos; ++ struct hlist_node *node; ++ ++ hlist_for_each_entry_safe(pos, node, head, wh_hash) ++ au_kfree_rcu(pos); ++} ++ ++static void au_nhash_de_do_free(struct hlist_head *head) ++{ ++ struct au_vdir_dehstr *pos; ++ struct hlist_node *node; ++ ++ hlist_for_each_entry_safe(pos, node, head, hash) ++ au_cache_free_vdir_dehstr(pos); ++} ++ ++static void au_nhash_do_free(struct au_nhash *nhash, ++ void (*free)(struct hlist_head *head)) ++{ ++ unsigned int n; ++ struct hlist_head *head; ++ ++ n = nhash->nh_num; ++ if (!n) ++ return; ++ ++ head = nhash->nh_head; ++ while (n-- > 0) { ++ nhash_count(head); ++ free(head++); ++ } ++ au_kfree_try_rcu(nhash->nh_head); ++} ++ ++void au_nhash_wh_free(struct au_nhash *whlist) ++{ ++ au_nhash_do_free(whlist, au_nhash_wh_do_free); ++} ++ ++static void au_nhash_de_free(struct au_nhash *delist) ++{ ++ au_nhash_do_free(delist, au_nhash_de_do_free); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_nhash_test_longer_wh(struct au_nhash *whlist, aufs_bindex_t btgt, ++ int limit) ++{ ++ int num; ++ unsigned int u, n; ++ struct hlist_head *head; ++ struct au_vdir_wh *pos; ++ ++ num = 0; ++ n = whlist->nh_num; ++ head = whlist->nh_head; ++ for (u = 0; u < n; u++, head++) ++ hlist_for_each_entry(pos, head, wh_hash) ++ if (pos->wh_bindex == btgt && ++num > limit) ++ return 1; ++ return 0; ++} ++ ++static struct hlist_head *au_name_hash(struct au_nhash *nhash, ++ unsigned char *name, ++ unsigned int len) ++{ ++ unsigned int v; ++ /* const unsigned int magic_bit = 12; */ ++ ++ AuDebugOn(!nhash->nh_num || !nhash->nh_head); ++ ++ v = 0; ++ if (len > 8) ++ len = 8; ++ while (len--) ++ v += *name++; ++ /* v = hash_long(v, magic_bit); */ ++ v %= nhash->nh_num; ++ return nhash->nh_head + v; ++} ++ ++static int au_nhash_test_name(struct au_vdir_destr *str, const char *name, ++ int nlen) ++{ ++ return str->len == nlen && !memcmp(str->name, name, nlen); ++} ++ ++/* returns found or not */ ++int au_nhash_test_known_wh(struct au_nhash *whlist, char *name, int nlen) ++{ ++ struct hlist_head *head; ++ struct au_vdir_wh *pos; ++ struct au_vdir_destr *str; ++ ++ head = au_name_hash(whlist, name, nlen); ++ hlist_for_each_entry(pos, head, wh_hash) { ++ str = &pos->wh_str; ++ AuDbg("%.*s\n", str->len, str->name); ++ if (au_nhash_test_name(str, name, nlen)) ++ return 1; ++ } ++ return 0; ++} ++ ++/* returns found(true) or not */ ++static int test_known(struct au_nhash *delist, char *name, int nlen) ++{ ++ struct hlist_head *head; ++ struct au_vdir_dehstr *pos; ++ struct au_vdir_destr *str; ++ ++ head = au_name_hash(delist, name, nlen); ++ hlist_for_each_entry(pos, head, hash) { ++ str = pos->str; ++ AuDbg("%.*s\n", str->len, str->name); ++ if (au_nhash_test_name(str, name, nlen)) ++ return 1; ++ } ++ return 0; ++} ++ ++static void au_shwh_init_wh(struct au_vdir_wh *wh, ino_t ino, ++ unsigned char d_type) ++{ ++#ifdef CONFIG_AUFS_SHWH ++ wh->wh_ino = ino; ++ wh->wh_type = d_type; ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_nhash_append_wh(struct au_nhash *whlist, char *name, int nlen, ino_t ino, ++ unsigned int d_type, aufs_bindex_t bindex, ++ unsigned char shwh) ++{ ++ int err; ++ struct au_vdir_destr *str; ++ struct au_vdir_wh *wh; ++ ++ AuDbg("%.*s\n", nlen, name); ++ AuDebugOn(!whlist->nh_num || !whlist->nh_head); ++ ++ err = -ENOMEM; ++ wh = kmalloc(sizeof(*wh) + nlen, GFP_NOFS); ++ if (unlikely(!wh)) ++ goto out; ++ ++ err = 0; ++ wh->wh_bindex = bindex; ++ if (shwh) ++ au_shwh_init_wh(wh, ino, d_type); ++ str = &wh->wh_str; ++ str->len = nlen; ++ memcpy(str->name, name, nlen); ++ hlist_add_head(&wh->wh_hash, au_name_hash(whlist, name, nlen)); ++ /* smp_mb(); */ ++ ++out: ++ return err; ++} ++ ++static int append_deblk(struct au_vdir *vdir) ++{ ++ int err; ++ unsigned long ul; ++ const unsigned int deblk_sz = vdir->vd_deblk_sz; ++ union au_vdir_deblk_p p, deblk_end; ++ unsigned char **o; ++ ++ err = -ENOMEM; ++ o = au_krealloc(vdir->vd_deblk, sizeof(*o) * (vdir->vd_nblk + 1), ++ GFP_NOFS, /*may_shrink*/0); ++ if (unlikely(!o)) ++ goto out; ++ ++ vdir->vd_deblk = o; ++ p.deblk = kmalloc(deblk_sz, GFP_NOFS); ++ if (p.deblk) { ++ ul = vdir->vd_nblk++; ++ vdir->vd_deblk[ul] = p.deblk; ++ vdir->vd_last.ul = ul; ++ vdir->vd_last.p.deblk = p.deblk; ++ deblk_end.deblk = p.deblk + deblk_sz; ++ err = set_deblk_end(&p, &deblk_end); ++ } ++ ++out: ++ return err; ++} ++ ++static int append_de(struct au_vdir *vdir, char *name, int nlen, ino_t ino, ++ unsigned int d_type, struct au_nhash *delist) ++{ ++ int err; ++ unsigned int sz; ++ const unsigned int deblk_sz = vdir->vd_deblk_sz; ++ union au_vdir_deblk_p p, *room, deblk_end; ++ struct au_vdir_dehstr *dehstr; ++ ++ p.deblk = last_deblk(vdir); ++ deblk_end.deblk = p.deblk + deblk_sz; ++ room = &vdir->vd_last.p; ++ AuDebugOn(room->deblk < p.deblk || deblk_end.deblk <= room->deblk ++ || !is_deblk_end(room, &deblk_end)); ++ ++ sz = calc_size(nlen); ++ if (unlikely(sz > deblk_end.deblk - room->deblk)) { ++ err = append_deblk(vdir); ++ if (unlikely(err)) ++ goto out; ++ ++ p.deblk = last_deblk(vdir); ++ deblk_end.deblk = p.deblk + deblk_sz; ++ /* smp_mb(); */ ++ AuDebugOn(room->deblk != p.deblk); ++ } ++ ++ err = -ENOMEM; ++ dehstr = au_cache_alloc_vdir_dehstr(); ++ if (unlikely(!dehstr)) ++ goto out; ++ ++ dehstr->str = &room->de->de_str; ++ hlist_add_head(&dehstr->hash, au_name_hash(delist, name, nlen)); ++ room->de->de_ino = ino; ++ room->de->de_type = d_type; ++ room->de->de_str.len = nlen; ++ memcpy(room->de->de_str.name, name, nlen); ++ ++ err = 0; ++ room->deblk += sz; ++ if (unlikely(set_deblk_end(room, &deblk_end))) ++ err = append_deblk(vdir); ++ /* smp_mb(); */ ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_vdir_free(struct au_vdir *vdir) ++{ ++ unsigned char **deblk; ++ ++ deblk = vdir->vd_deblk; ++ while (vdir->vd_nblk--) ++ au_kfree_try_rcu(*deblk++); ++ au_kfree_try_rcu(vdir->vd_deblk); ++ au_cache_free_vdir(vdir); ++} ++ ++static struct au_vdir *alloc_vdir(struct file *file) ++{ ++ struct au_vdir *vdir; ++ struct super_block *sb; ++ int err; ++ ++ sb = file->f_path.dentry->d_sb; ++ SiMustAnyLock(sb); ++ ++ err = -ENOMEM; ++ vdir = au_cache_alloc_vdir(); ++ if (unlikely(!vdir)) ++ goto out; ++ ++ vdir->vd_deblk = kzalloc(sizeof(*vdir->vd_deblk), GFP_NOFS); ++ if (unlikely(!vdir->vd_deblk)) ++ goto out_free; ++ ++ vdir->vd_deblk_sz = au_sbi(sb)->si_rdblk; ++ if (!vdir->vd_deblk_sz) { ++ /* estimate the appropriate size for deblk */ ++ vdir->vd_deblk_sz = au_dir_size(file, /*dentry*/NULL); ++ /* pr_info("vd_deblk_sz %u\n", vdir->vd_deblk_sz); */ ++ } ++ vdir->vd_nblk = 0; ++ vdir->vd_version = 0; ++ vdir->vd_jiffy = 0; ++ err = append_deblk(vdir); ++ if (!err) ++ return vdir; /* success */ ++ ++ au_kfree_try_rcu(vdir->vd_deblk); ++ ++out_free: ++ au_cache_free_vdir(vdir); ++out: ++ vdir = ERR_PTR(err); ++ return vdir; ++} ++ ++static int reinit_vdir(struct au_vdir *vdir) ++{ ++ int err; ++ union au_vdir_deblk_p p, deblk_end; ++ ++ while (vdir->vd_nblk > 1) { ++ au_kfree_try_rcu(vdir->vd_deblk[vdir->vd_nblk - 1]); ++ /* vdir->vd_deblk[vdir->vd_nblk - 1] = NULL; */ ++ vdir->vd_nblk--; ++ } ++ p.deblk = vdir->vd_deblk[0]; ++ deblk_end.deblk = p.deblk + vdir->vd_deblk_sz; ++ err = set_deblk_end(&p, &deblk_end); ++ /* keep vd_dblk_sz */ ++ vdir->vd_last.ul = 0; ++ vdir->vd_last.p.deblk = vdir->vd_deblk[0]; ++ vdir->vd_version = 0; ++ vdir->vd_jiffy = 0; ++ /* smp_mb(); */ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define AuFillVdir_CALLED 1 ++#define AuFillVdir_WHABLE (1 << 1) ++#define AuFillVdir_SHWH (1 << 2) ++#define au_ftest_fillvdir(flags, name) ((flags) & AuFillVdir_##name) ++#define au_fset_fillvdir(flags, name) \ ++ do { (flags) |= AuFillVdir_##name; } while (0) ++#define au_fclr_fillvdir(flags, name) \ ++ do { (flags) &= ~AuFillVdir_##name; } while (0) ++ ++#ifndef CONFIG_AUFS_SHWH ++#undef AuFillVdir_SHWH ++#define AuFillVdir_SHWH 0 ++#endif ++ ++struct fillvdir_arg { ++ struct dir_context ctx; ++ struct file *file; ++ struct au_vdir *vdir; ++ struct au_nhash delist; ++ struct au_nhash whlist; ++ aufs_bindex_t bindex; ++ unsigned int flags; ++ int err; ++}; ++ ++static int fillvdir(struct dir_context *ctx, const char *__name, int nlen, ++ loff_t offset __maybe_unused, u64 h_ino, ++ unsigned int d_type) ++{ ++ struct fillvdir_arg *arg = container_of(ctx, struct fillvdir_arg, ctx); ++ char *name = (void *)__name; ++ struct super_block *sb; ++ ino_t ino; ++ const unsigned char shwh = !!au_ftest_fillvdir(arg->flags, SHWH); ++ ++ arg->err = 0; ++ sb = arg->file->f_path.dentry->d_sb; ++ au_fset_fillvdir(arg->flags, CALLED); ++ /* smp_mb(); */ ++ if (nlen <= AUFS_WH_PFX_LEN ++ || memcmp(name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) { ++ if (test_known(&arg->delist, name, nlen) ++ || au_nhash_test_known_wh(&arg->whlist, name, nlen)) ++ goto out; /* already exists or whiteouted */ ++ ++ arg->err = au_ino(sb, arg->bindex, h_ino, d_type, &ino); ++ if (!arg->err) { ++ if (unlikely(nlen > AUFS_MAX_NAMELEN)) ++ d_type = DT_UNKNOWN; ++ arg->err = append_de(arg->vdir, name, nlen, ino, ++ d_type, &arg->delist); ++ } ++ } else if (au_ftest_fillvdir(arg->flags, WHABLE)) { ++ name += AUFS_WH_PFX_LEN; ++ nlen -= AUFS_WH_PFX_LEN; ++ if (au_nhash_test_known_wh(&arg->whlist, name, nlen)) ++ goto out; /* already whiteouted */ ++ ++ ino = 0; /* just to suppress a warning */ ++ if (shwh) ++ arg->err = au_wh_ino(sb, arg->bindex, h_ino, d_type, ++ &ino); ++ if (!arg->err) { ++ if (nlen <= AUFS_MAX_NAMELEN + AUFS_WH_PFX_LEN) ++ d_type = DT_UNKNOWN; ++ arg->err = au_nhash_append_wh ++ (&arg->whlist, name, nlen, ino, d_type, ++ arg->bindex, shwh); ++ } ++ } ++ ++out: ++ if (!arg->err) ++ arg->vdir->vd_jiffy = jiffies; ++ /* smp_mb(); */ ++ AuTraceErr(arg->err); ++ return arg->err; ++} ++ ++static int au_handle_shwh(struct super_block *sb, struct au_vdir *vdir, ++ struct au_nhash *whlist, struct au_nhash *delist) ++{ ++#ifdef CONFIG_AUFS_SHWH ++ int err; ++ unsigned int nh, u; ++ struct hlist_head *head; ++ struct au_vdir_wh *pos; ++ struct hlist_node *n; ++ char *p, *o; ++ struct au_vdir_destr *destr; ++ ++ AuDebugOn(!au_opt_test(au_mntflags(sb), SHWH)); ++ ++ err = -ENOMEM; ++ o = p = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!p)) ++ goto out; ++ ++ err = 0; ++ nh = whlist->nh_num; ++ memcpy(p, AUFS_WH_PFX, AUFS_WH_PFX_LEN); ++ p += AUFS_WH_PFX_LEN; ++ for (u = 0; u < nh; u++) { ++ head = whlist->nh_head + u; ++ hlist_for_each_entry_safe(pos, n, head, wh_hash) { ++ destr = &pos->wh_str; ++ memcpy(p, destr->name, destr->len); ++ err = append_de(vdir, o, destr->len + AUFS_WH_PFX_LEN, ++ pos->wh_ino, pos->wh_type, delist); ++ if (unlikely(err)) ++ break; ++ } ++ } ++ ++ free_page((unsigned long)o); ++ ++out: ++ AuTraceErr(err); ++ return err; ++#else ++ return 0; ++#endif ++} ++ ++static int au_do_read_vdir(struct fillvdir_arg *arg) ++{ ++ int err; ++ unsigned int rdhash; ++ loff_t offset; ++ aufs_bindex_t bbot, bindex, btop; ++ unsigned char shwh; ++ struct file *hf, *file; ++ struct super_block *sb; ++ ++ file = arg->file; ++ sb = file->f_path.dentry->d_sb; ++ SiMustAnyLock(sb); ++ ++ rdhash = au_sbi(sb)->si_rdhash; ++ if (!rdhash) ++ rdhash = au_rdhash_est(au_dir_size(file, /*dentry*/NULL)); ++ err = au_nhash_alloc(&arg->delist, rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_nhash_alloc(&arg->whlist, rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out_delist; ++ ++ err = 0; ++ arg->flags = 0; ++ shwh = 0; ++ if (au_opt_test(au_mntflags(sb), SHWH)) { ++ shwh = 1; ++ au_fset_fillvdir(arg->flags, SHWH); ++ } ++ btop = au_fbtop(file); ++ bbot = au_fbbot_dir(file); ++ for (bindex = btop; !err && bindex <= bbot; bindex++) { ++ hf = au_hf_dir(file, bindex); ++ if (!hf) ++ continue; ++ ++ offset = vfsub_llseek(hf, 0, SEEK_SET); ++ err = offset; ++ if (unlikely(offset)) ++ break; ++ ++ arg->bindex = bindex; ++ au_fclr_fillvdir(arg->flags, WHABLE); ++ if (shwh ++ || (bindex != bbot ++ && au_br_whable(au_sbr_perm(sb, bindex)))) ++ au_fset_fillvdir(arg->flags, WHABLE); ++ do { ++ arg->err = 0; ++ au_fclr_fillvdir(arg->flags, CALLED); ++ /* smp_mb(); */ ++ err = vfsub_iterate_dir(hf, &arg->ctx); ++ if (err >= 0) ++ err = arg->err; ++ } while (!err && au_ftest_fillvdir(arg->flags, CALLED)); ++ ++ /* ++ * dir_relax() may be good for concurrency, but aufs should not ++ * use it since it will cause a lockdep problem. ++ */ ++ } ++ ++ if (!err && shwh) ++ err = au_handle_shwh(sb, arg->vdir, &arg->whlist, &arg->delist); ++ ++ au_nhash_wh_free(&arg->whlist); ++ ++out_delist: ++ au_nhash_de_free(&arg->delist); ++out: ++ return err; ++} ++ ++static int read_vdir(struct file *file, int may_read) ++{ ++ int err; ++ unsigned long expire; ++ unsigned char do_read; ++ struct fillvdir_arg arg = { ++ .ctx = { ++ .actor = fillvdir ++ } ++ }; ++ struct inode *inode; ++ struct au_vdir *vdir, *allocated; ++ ++ err = 0; ++ inode = file_inode(file); ++ IMustLock(inode); ++ IiMustWriteLock(inode); ++ SiMustAnyLock(inode->i_sb); ++ ++ allocated = NULL; ++ do_read = 0; ++ expire = au_sbi(inode->i_sb)->si_rdcache; ++ vdir = au_ivdir(inode); ++ if (!vdir) { ++ do_read = 1; ++ vdir = alloc_vdir(file); ++ err = PTR_ERR(vdir); ++ if (IS_ERR(vdir)) ++ goto out; ++ err = 0; ++ allocated = vdir; ++ } else if (may_read ++ && (!inode_eq_iversion(inode, vdir->vd_version) ++ || time_after(jiffies, vdir->vd_jiffy + expire))) { ++ do_read = 1; ++ err = reinit_vdir(vdir); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ if (!do_read) ++ return 0; /* success */ ++ ++ arg.file = file; ++ arg.vdir = vdir; ++ err = au_do_read_vdir(&arg); ++ if (!err) { ++ /* file->f_pos = 0; */ /* todo: ctx->pos? */ ++ vdir->vd_version = inode_query_iversion(inode); ++ vdir->vd_last.ul = 0; ++ vdir->vd_last.p.deblk = vdir->vd_deblk[0]; ++ if (allocated) ++ au_set_ivdir(inode, allocated); ++ } else if (allocated) ++ au_vdir_free(allocated); ++ ++out: ++ return err; ++} ++ ++static int copy_vdir(struct au_vdir *tgt, struct au_vdir *src) ++{ ++ int err, rerr; ++ unsigned long ul, n; ++ const unsigned int deblk_sz = src->vd_deblk_sz; ++ ++ AuDebugOn(tgt->vd_nblk != 1); ++ ++ err = -ENOMEM; ++ if (tgt->vd_nblk < src->vd_nblk) { ++ unsigned char **p; ++ ++ p = au_krealloc(tgt->vd_deblk, sizeof(*p) * src->vd_nblk, ++ GFP_NOFS, /*may_shrink*/0); ++ if (unlikely(!p)) ++ goto out; ++ tgt->vd_deblk = p; ++ } ++ ++ if (tgt->vd_deblk_sz != deblk_sz) { ++ unsigned char *p; ++ ++ tgt->vd_deblk_sz = deblk_sz; ++ p = au_krealloc(tgt->vd_deblk[0], deblk_sz, GFP_NOFS, ++ /*may_shrink*/1); ++ if (unlikely(!p)) ++ goto out; ++ tgt->vd_deblk[0] = p; ++ } ++ memcpy(tgt->vd_deblk[0], src->vd_deblk[0], deblk_sz); ++ tgt->vd_version = src->vd_version; ++ tgt->vd_jiffy = src->vd_jiffy; ++ ++ n = src->vd_nblk; ++ for (ul = 1; ul < n; ul++) { ++ tgt->vd_deblk[ul] = kmemdup(src->vd_deblk[ul], deblk_sz, ++ GFP_NOFS); ++ if (unlikely(!tgt->vd_deblk[ul])) ++ goto out; ++ tgt->vd_nblk++; ++ } ++ tgt->vd_nblk = n; ++ tgt->vd_last.ul = tgt->vd_last.ul; ++ tgt->vd_last.p.deblk = tgt->vd_deblk[tgt->vd_last.ul]; ++ tgt->vd_last.p.deblk += src->vd_last.p.deblk ++ - src->vd_deblk[src->vd_last.ul]; ++ /* smp_mb(); */ ++ return 0; /* success */ ++ ++out: ++ rerr = reinit_vdir(tgt); ++ BUG_ON(rerr); ++ return err; ++} ++ ++int au_vdir_init(struct file *file) ++{ ++ int err; ++ struct inode *inode; ++ struct au_vdir *vdir_cache, *allocated; ++ ++ /* test file->f_pos here instead of ctx->pos */ ++ err = read_vdir(file, !file->f_pos); ++ if (unlikely(err)) ++ goto out; ++ ++ allocated = NULL; ++ vdir_cache = au_fvdir_cache(file); ++ if (!vdir_cache) { ++ vdir_cache = alloc_vdir(file); ++ err = PTR_ERR(vdir_cache); ++ if (IS_ERR(vdir_cache)) ++ goto out; ++ allocated = vdir_cache; ++ } else if (!file->f_pos && vdir_cache->vd_version != file->f_version) { ++ /* test file->f_pos here instead of ctx->pos */ ++ err = reinit_vdir(vdir_cache); ++ if (unlikely(err)) ++ goto out; ++ } else ++ return 0; /* success */ ++ ++ inode = file_inode(file); ++ err = copy_vdir(vdir_cache, au_ivdir(inode)); ++ if (!err) { ++ file->f_version = inode_query_iversion(inode); ++ if (allocated) ++ au_set_fvdir_cache(file, allocated); ++ } else if (allocated) ++ au_vdir_free(allocated); ++ ++out: ++ return err; ++} ++ ++static loff_t calc_offset(struct au_vdir *vdir) ++{ ++ loff_t offset; ++ union au_vdir_deblk_p p; ++ ++ p.deblk = vdir->vd_deblk[vdir->vd_last.ul]; ++ offset = vdir->vd_last.p.deblk - p.deblk; ++ offset += vdir->vd_deblk_sz * vdir->vd_last.ul; ++ return offset; ++} ++ ++/* returns true or false */ ++static int seek_vdir(struct file *file, struct dir_context *ctx) ++{ ++ int valid; ++ unsigned int deblk_sz; ++ unsigned long ul, n; ++ loff_t offset; ++ union au_vdir_deblk_p p, deblk_end; ++ struct au_vdir *vdir_cache; ++ ++ valid = 1; ++ vdir_cache = au_fvdir_cache(file); ++ offset = calc_offset(vdir_cache); ++ AuDbg("offset %lld\n", offset); ++ if (ctx->pos == offset) ++ goto out; ++ ++ vdir_cache->vd_last.ul = 0; ++ vdir_cache->vd_last.p.deblk = vdir_cache->vd_deblk[0]; ++ if (!ctx->pos) ++ goto out; ++ ++ valid = 0; ++ deblk_sz = vdir_cache->vd_deblk_sz; ++ ul = div64_u64(ctx->pos, deblk_sz); ++ AuDbg("ul %lu\n", ul); ++ if (ul >= vdir_cache->vd_nblk) ++ goto out; ++ ++ n = vdir_cache->vd_nblk; ++ for (; ul < n; ul++) { ++ p.deblk = vdir_cache->vd_deblk[ul]; ++ deblk_end.deblk = p.deblk + deblk_sz; ++ offset = ul; ++ offset *= deblk_sz; ++ while (!is_deblk_end(&p, &deblk_end) && offset < ctx->pos) { ++ unsigned int l; ++ ++ l = calc_size(p.de->de_str.len); ++ offset += l; ++ p.deblk += l; ++ } ++ if (!is_deblk_end(&p, &deblk_end)) { ++ valid = 1; ++ vdir_cache->vd_last.ul = ul; ++ vdir_cache->vd_last.p = p; ++ break; ++ } ++ } ++ ++out: ++ /* smp_mb(); */ ++ if (!valid) ++ AuDbg("valid %d\n", !valid); ++ return valid; ++} ++ ++int au_vdir_fill_de(struct file *file, struct dir_context *ctx) ++{ ++ unsigned int l, deblk_sz; ++ union au_vdir_deblk_p deblk_end; ++ struct au_vdir *vdir_cache; ++ struct au_vdir_de *de; ++ ++ if (!seek_vdir(file, ctx)) ++ return 0; ++ ++ vdir_cache = au_fvdir_cache(file); ++ deblk_sz = vdir_cache->vd_deblk_sz; ++ while (1) { ++ deblk_end.deblk = vdir_cache->vd_deblk[vdir_cache->vd_last.ul]; ++ deblk_end.deblk += deblk_sz; ++ while (!is_deblk_end(&vdir_cache->vd_last.p, &deblk_end)) { ++ de = vdir_cache->vd_last.p.de; ++ AuDbg("%.*s, off%lld, i%lu, dt%d\n", ++ de->de_str.len, de->de_str.name, ctx->pos, ++ (unsigned long)de->de_ino, de->de_type); ++ if (unlikely(!dir_emit(ctx, de->de_str.name, ++ de->de_str.len, de->de_ino, ++ de->de_type))) { ++ /* todo: ignore the error caused by udba? */ ++ /* return err; */ ++ return 0; ++ } ++ ++ l = calc_size(de->de_str.len); ++ vdir_cache->vd_last.p.deblk += l; ++ ctx->pos += l; ++ } ++ if (vdir_cache->vd_last.ul < vdir_cache->vd_nblk - 1) { ++ vdir_cache->vd_last.ul++; ++ vdir_cache->vd_last.p.deblk ++ = vdir_cache->vd_deblk[vdir_cache->vd_last.ul]; ++ ctx->pos = deblk_sz * vdir_cache->vd_last.ul; ++ continue; ++ } ++ break; ++ } ++ ++ /* smp_mb(); */ ++ return 0; ++} +diff --git a/fs/aufs/vfsub.c b/fs/aufs/vfsub.c +new file mode 100644 +index 000000000000..3217455dc21b +--- /dev/null ++++ b/fs/aufs/vfsub.c +@@ -0,0 +1,882 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * sub-routines for VFS ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include "aufs.h" ++ ++#ifdef CONFIG_AUFS_BR_FUSE ++int vfsub_test_mntns(struct vfsmount *mnt, struct super_block *h_sb) ++{ ++ if (!au_test_fuse(h_sb) || !au_userns) ++ return 0; ++ ++ return is_current_mnt_ns(mnt) ? 0 : -EACCES; ++} ++#endif ++ ++int vfsub_sync_filesystem(struct super_block *h_sb, int wait) ++{ ++ int err; ++ ++ lockdep_off(); ++ down_read(&h_sb->s_umount); ++ err = __sync_filesystem(h_sb, wait); ++ up_read(&h_sb->s_umount); ++ lockdep_on(); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int vfsub_update_h_iattr(struct path *h_path, int *did) ++{ ++ int err; ++ struct kstat st; ++ struct super_block *h_sb; ++ ++ /* for remote fs, leave work for its getattr or d_revalidate */ ++ /* for bad i_attr fs, handle them in aufs_getattr() */ ++ /* still some fs may acquire i_mutex. we need to skip them */ ++ err = 0; ++ if (!did) ++ did = &err; ++ h_sb = h_path->dentry->d_sb; ++ *did = (!au_test_fs_remote(h_sb) && au_test_fs_refresh_iattr(h_sb)); ++ if (*did) ++ err = vfsub_getattr(h_path, &st); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct file *vfsub_dentry_open(struct path *path, int flags) ++{ ++ return dentry_open(path, flags /* | __FMODE_NONOTIFY */, ++ current_cred()); ++} ++ ++struct file *vfsub_filp_open(const char *path, int oflags, int mode) ++{ ++ struct file *file; ++ ++ lockdep_off(); ++ file = filp_open(path, ++ oflags /* | __FMODE_NONOTIFY */, ++ mode); ++ lockdep_on(); ++ if (IS_ERR(file)) ++ goto out; ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ ++out: ++ return file; ++} ++ ++/* ++ * Ideally this function should call VFS:do_last() in order to keep all its ++ * checkings. But it is very hard for aufs to regenerate several VFS internal ++ * structure such as nameidata. This is a second (or third) best approach. ++ * cf. linux/fs/namei.c:do_last(), lookup_open() and atomic_open(). ++ */ ++int vfsub_atomic_open(struct inode *dir, struct dentry *dentry, ++ struct vfsub_aopen_args *args) ++{ ++ int err; ++ struct au_branch *br = args->br; ++ struct file *file = args->file; ++ /* copied from linux/fs/namei.c:atomic_open() */ ++ struct dentry *const DENTRY_NOT_SET = (void *)-1UL; ++ ++ IMustLock(dir); ++ AuDebugOn(!dir->i_op->atomic_open); ++ ++ err = au_br_test_oflag(args->open_flag, br); ++ if (unlikely(err)) ++ goto out; ++ ++ au_lcnt_inc(&br->br_nfiles); ++ file->f_path.dentry = DENTRY_NOT_SET; ++ file->f_path.mnt = au_br_mnt(br); ++ AuDbg("%ps\n", dir->i_op->atomic_open); ++ err = dir->i_op->atomic_open(dir, dentry, file, args->open_flag, ++ args->create_mode); ++ if (unlikely(err < 0)) { ++ au_lcnt_dec(&br->br_nfiles); ++ goto out; ++ } ++ ++ /* temporary workaround for nfsv4 branch */ ++ if (au_test_nfs(dir->i_sb)) ++ nfs_mark_for_revalidate(dir); ++ ++ if (file->f_mode & FMODE_CREATED) ++ fsnotify_create(dir, dentry); ++ if (!(file->f_mode & FMODE_OPENED)) { ++ au_lcnt_dec(&br->br_nfiles); ++ goto out; ++ } ++ ++ /* todo: call VFS:may_open() here */ ++ /* todo: ima_file_check() too? */ ++ if (!err && (args->open_flag & __FMODE_EXEC)) ++ err = deny_write_access(file); ++ if (!err) ++ fsnotify_open(file); ++ else ++ au_lcnt_dec(&br->br_nfiles); ++ /* note that the file is created and still opened */ ++ ++out: ++ return err; ++} ++ ++int vfsub_kern_path(const char *name, unsigned int flags, struct path *path) ++{ ++ int err; ++ ++ err = kern_path(name, flags, path); ++ if (!err && d_is_positive(path->dentry)) ++ vfsub_update_h_iattr(path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++struct dentry *vfsub_lookup_one_len_unlocked(const char *name, ++ struct dentry *parent, int len) ++{ ++ struct path path = { ++ .mnt = NULL ++ }; ++ ++ path.dentry = lookup_one_len_unlocked(name, parent, len); ++ if (IS_ERR(path.dentry)) ++ goto out; ++ if (d_is_positive(path.dentry)) ++ vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/ ++ ++out: ++ AuTraceErrPtr(path.dentry); ++ return path.dentry; ++} ++ ++struct dentry *vfsub_lookup_one_len(const char *name, struct dentry *parent, ++ int len) ++{ ++ struct path path = { ++ .mnt = NULL ++ }; ++ ++ /* VFS checks it too, but by WARN_ON_ONCE() */ ++ IMustLock(d_inode(parent)); ++ ++ path.dentry = lookup_one_len(name, parent, len); ++ if (IS_ERR(path.dentry)) ++ goto out; ++ if (d_is_positive(path.dentry)) ++ vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/ ++ ++out: ++ AuTraceErrPtr(path.dentry); ++ return path.dentry; ++} ++ ++void vfsub_call_lkup_one(void *args) ++{ ++ struct vfsub_lkup_one_args *a = args; ++ *a->errp = vfsub_lkup_one(a->name, a->parent); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct dentry *vfsub_lock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2) ++{ ++ struct dentry *d; ++ ++ lockdep_off(); ++ d = lock_rename(d1, d2); ++ lockdep_on(); ++ au_hn_suspend(hdir1); ++ if (hdir1 != hdir2) ++ au_hn_suspend(hdir2); ++ ++ return d; ++} ++ ++void vfsub_unlock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2) ++{ ++ au_hn_resume(hdir1); ++ if (hdir1 != hdir2) ++ au_hn_resume(hdir2); ++ lockdep_off(); ++ unlock_rename(d1, d2); ++ lockdep_on(); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int vfsub_create(struct inode *dir, struct path *path, int mode, bool want_excl) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_mknod(path, d, mode, 0); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_create(dir, path->dentry, mode, want_excl); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++out: ++ return err; ++} ++ ++int vfsub_symlink(struct inode *dir, struct path *path, const char *symname) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_symlink(path, d, symname); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_symlink(dir, path->dentry, symname); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++out: ++ return err; ++} ++ ++int vfsub_mknod(struct inode *dir, struct path *path, int mode, dev_t dev) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_mknod(path, d, mode, new_encode_dev(dev)); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_mknod(dir, path->dentry, mode, dev); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++out: ++ return err; ++} ++ ++static int au_test_nlink(struct inode *inode) ++{ ++ const unsigned int link_max = UINT_MAX >> 1; /* rough margin */ ++ ++ if (!au_test_fs_no_limit_nlink(inode->i_sb) ++ || inode->i_nlink < link_max) ++ return 0; ++ return -EMLINK; ++} ++ ++int vfsub_link(struct dentry *src_dentry, struct inode *dir, struct path *path, ++ struct inode **delegated_inode) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ err = au_test_nlink(d_inode(src_dentry)); ++ if (unlikely(err)) ++ return err; ++ ++ /* we don't call may_linkat() */ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_link(src_dentry, path, d); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_link(src_dentry, dir, path->dentry, delegated_inode); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ /* fuse has different memory inode for the same inumber */ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ tmp.dentry = src_dentry; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++out: ++ return err; ++} ++ ++int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry, ++ struct inode *dir, struct path *path, ++ struct inode **delegated_inode, unsigned int flags) ++{ ++ int err; ++ struct path tmp = { ++ .mnt = path->mnt ++ }; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ IMustLock(src_dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ tmp.dentry = src_dentry->d_parent; ++ err = security_path_rename(&tmp, src_dentry, path, d, /*flags*/0); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_rename(src_dir, src_dentry, dir, path->dentry, ++ delegated_inode, flags); ++ lockdep_on(); ++ if (!err) { ++ int did; ++ ++ tmp.dentry = d->d_parent; ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = src_dentry; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ tmp.dentry = src_dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++out: ++ return err; ++} ++ ++int vfsub_mkdir(struct inode *dir, struct path *path, int mode) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_mkdir(path, d, mode); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_mkdir(dir, path->dentry, mode); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++out: ++ return err; ++} ++ ++int vfsub_rmdir(struct inode *dir, struct path *path) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_rmdir(path, d); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_rmdir(dir, path->dentry); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = { ++ .dentry = path->dentry->d_parent, ++ .mnt = path->mnt ++ }; ++ ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); /*ignore*/ ++ } ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* todo: support mmap_sem? */ ++ssize_t vfsub_read_u(struct file *file, char __user *ubuf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ ++ lockdep_off(); ++ err = vfs_read(file, ubuf, count, ppos); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++/* todo: kernel_read()? */ ++ssize_t vfsub_read_k(struct file *file, void *kbuf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ union { ++ void *k; ++ char __user *u; ++ } buf; ++ ++ buf.k = kbuf; ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ err = vfsub_read_u(file, buf.u, count, ppos); ++ set_fs(oldfs); ++ return err; ++} ++ ++ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ ++ lockdep_off(); ++ err = vfs_write(file, ubuf, count, ppos); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++ssize_t vfsub_write_k(struct file *file, void *kbuf, size_t count, loff_t *ppos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ union { ++ void *k; ++ const char __user *u; ++ } buf; ++ ++ buf.k = kbuf; ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ err = vfsub_write_u(file, buf.u, count, ppos); ++ set_fs(oldfs); ++ return err; ++} ++ ++int vfsub_flush(struct file *file, fl_owner_t id) ++{ ++ int err; ++ ++ err = 0; ++ if (file->f_op->flush) { ++ if (!au_test_nfs(file->f_path.dentry->d_sb)) ++ err = file->f_op->flush(file, id); ++ else { ++ lockdep_off(); ++ err = file->f_op->flush(file, id); ++ lockdep_on(); ++ } ++ if (!err) ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); ++ /*ignore*/ ++ } ++ return err; ++} ++ ++int vfsub_iterate_dir(struct file *file, struct dir_context *ctx) ++{ ++ int err; ++ ++ AuDbg("%pD, ctx{%ps, %llu}\n", file, ctx->actor, ctx->pos); ++ ++ lockdep_off(); ++ err = iterate_dir(file, ctx); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ ++ return err; ++} ++ ++long vfsub_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags) ++{ ++ long err; ++ ++ lockdep_off(); ++ err = do_splice_to(in, ppos, pipe, len, flags); ++ lockdep_on(); ++ file_accessed(in); ++ if (err >= 0) ++ vfsub_update_h_iattr(&in->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags) ++{ ++ long err; ++ ++ lockdep_off(); ++ err = do_splice_from(pipe, out, ppos, len, flags); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&out->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++int vfsub_fsync(struct file *file, struct path *path, int datasync) ++{ ++ int err; ++ ++ /* file can be NULL */ ++ lockdep_off(); ++ err = vfs_fsync(file, datasync); ++ lockdep_on(); ++ if (!err) { ++ if (!path) { ++ AuDebugOn(!file); ++ path = &file->f_path; ++ } ++ vfsub_update_h_iattr(path, /*did*/NULL); /*ignore*/ ++ } ++ return err; ++} ++ ++/* cf. open.c:do_sys_truncate() and do_sys_ftruncate() */ ++int vfsub_trunc(struct path *h_path, loff_t length, unsigned int attr, ++ struct file *h_file) ++{ ++ int err; ++ struct inode *h_inode; ++ struct super_block *h_sb; ++ ++ if (!h_file) { ++ err = vfsub_truncate(h_path, length); ++ goto out; ++ } ++ ++ h_inode = d_inode(h_path->dentry); ++ h_sb = h_inode->i_sb; ++ lockdep_off(); ++ sb_start_write(h_sb); ++ lockdep_on(); ++ err = locks_verify_truncate(h_inode, h_file, length); ++ if (!err) ++ err = security_path_truncate(h_path); ++ if (!err) { ++ lockdep_off(); ++ err = do_truncate(h_path->dentry, length, attr, h_file); ++ lockdep_on(); ++ } ++ lockdep_off(); ++ sb_end_write(h_sb); ++ lockdep_on(); ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_vfsub_mkdir_args { ++ int *errp; ++ struct inode *dir; ++ struct path *path; ++ int mode; ++}; ++ ++static void au_call_vfsub_mkdir(void *args) ++{ ++ struct au_vfsub_mkdir_args *a = args; ++ *a->errp = vfsub_mkdir(a->dir, a->path, a->mode); ++} ++ ++int vfsub_sio_mkdir(struct inode *dir, struct path *path, int mode) ++{ ++ int err, do_sio, wkq_err; ++ ++ do_sio = au_test_h_perm_sio(dir, MAY_EXEC | MAY_WRITE); ++ if (!do_sio) { ++ lockdep_off(); ++ err = vfsub_mkdir(dir, path, mode); ++ lockdep_on(); ++ } else { ++ struct au_vfsub_mkdir_args args = { ++ .errp = &err, ++ .dir = dir, ++ .path = path, ++ .mode = mode ++ }; ++ wkq_err = au_wkq_wait(au_call_vfsub_mkdir, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} ++ ++struct au_vfsub_rmdir_args { ++ int *errp; ++ struct inode *dir; ++ struct path *path; ++}; ++ ++static void au_call_vfsub_rmdir(void *args) ++{ ++ struct au_vfsub_rmdir_args *a = args; ++ *a->errp = vfsub_rmdir(a->dir, a->path); ++} ++ ++int vfsub_sio_rmdir(struct inode *dir, struct path *path) ++{ ++ int err, do_sio, wkq_err; ++ ++ do_sio = au_test_h_perm_sio(dir, MAY_EXEC | MAY_WRITE); ++ if (!do_sio) { ++ lockdep_off(); ++ err = vfsub_rmdir(dir, path); ++ lockdep_on(); ++ } else { ++ struct au_vfsub_rmdir_args args = { ++ .errp = &err, ++ .dir = dir, ++ .path = path ++ }; ++ wkq_err = au_wkq_wait(au_call_vfsub_rmdir, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct notify_change_args { ++ int *errp; ++ struct path *path; ++ struct iattr *ia; ++ struct inode **delegated_inode; ++}; ++ ++static void call_notify_change(void *args) ++{ ++ struct notify_change_args *a = args; ++ struct inode *h_inode; ++ ++ h_inode = d_inode(a->path->dentry); ++ IMustLock(h_inode); ++ ++ *a->errp = -EPERM; ++ if (!IS_IMMUTABLE(h_inode) && !IS_APPEND(h_inode)) { ++ lockdep_off(); ++ *a->errp = notify_change(a->path->dentry, a->ia, ++ a->delegated_inode); ++ lockdep_on(); ++ if (!*a->errp) ++ vfsub_update_h_iattr(a->path, /*did*/NULL); /*ignore*/ ++ } ++ AuTraceErr(*a->errp); ++} ++ ++int vfsub_notify_change(struct path *path, struct iattr *ia, ++ struct inode **delegated_inode) ++{ ++ int err; ++ struct notify_change_args args = { ++ .errp = &err, ++ .path = path, ++ .ia = ia, ++ .delegated_inode = delegated_inode ++ }; ++ ++ call_notify_change(&args); ++ ++ return err; ++} ++ ++int vfsub_sio_notify_change(struct path *path, struct iattr *ia, ++ struct inode **delegated_inode) ++{ ++ int err, wkq_err; ++ struct notify_change_args args = { ++ .errp = &err, ++ .path = path, ++ .ia = ia, ++ .delegated_inode = delegated_inode ++ }; ++ ++ wkq_err = au_wkq_wait(call_notify_change, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct unlink_args { ++ int *errp; ++ struct inode *dir; ++ struct path *path; ++ struct inode **delegated_inode; ++}; ++ ++static void call_unlink(void *args) ++{ ++ struct unlink_args *a = args; ++ struct dentry *d = a->path->dentry; ++ struct inode *h_inode; ++ const int stop_sillyrename = (au_test_nfs(d->d_sb) ++ && au_dcount(d) == 1); ++ ++ IMustLock(a->dir); ++ ++ a->path->dentry = d->d_parent; ++ *a->errp = security_path_unlink(a->path, d); ++ a->path->dentry = d; ++ if (unlikely(*a->errp)) ++ return; ++ ++ if (!stop_sillyrename) ++ dget(d); ++ h_inode = NULL; ++ if (d_is_positive(d)) { ++ h_inode = d_inode(d); ++ ihold(h_inode); ++ } ++ ++ lockdep_off(); ++ *a->errp = vfs_unlink(a->dir, d, a->delegated_inode); ++ lockdep_on(); ++ if (!*a->errp) { ++ struct path tmp = { ++ .dentry = d->d_parent, ++ .mnt = a->path->mnt ++ }; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); /*ignore*/ ++ } ++ ++ if (!stop_sillyrename) ++ dput(d); ++ if (h_inode) ++ iput(h_inode); ++ ++ AuTraceErr(*a->errp); ++} ++ ++/* ++ * @dir: must be locked. ++ * @dentry: target dentry. ++ */ ++int vfsub_unlink(struct inode *dir, struct path *path, ++ struct inode **delegated_inode, int force) ++{ ++ int err; ++ struct unlink_args args = { ++ .errp = &err, ++ .dir = dir, ++ .path = path, ++ .delegated_inode = delegated_inode ++ }; ++ ++ if (!force) ++ call_unlink(&args); ++ else { ++ int wkq_err; ++ ++ wkq_err = au_wkq_wait(call_unlink, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} +diff --git a/fs/aufs/vfsub.h b/fs/aufs/vfsub.h +new file mode 100644 +index 000000000000..7d8993052cd5 +--- /dev/null ++++ b/fs/aufs/vfsub.h +@@ -0,0 +1,341 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * sub-routines for VFS ++ */ ++ ++#ifndef __AUFS_VFSUB_H__ ++#define __AUFS_VFSUB_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++#include ++#include ++#include ++#include "debug.h" ++ ++/* copied from linux/fs/internal.h */ ++/* todo: BAD approach!! */ ++extern void __mnt_drop_write(struct vfsmount *); ++extern struct file *alloc_empty_file(int, const struct cred *); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock subclass for lower inode */ ++/* default MAX_LOCKDEP_SUBCLASSES(8) is not enough */ ++/* reduce? gave up. */ ++enum { ++ AuLsc_I_Begin = I_MUTEX_PARENT2, /* 5 */ ++ AuLsc_I_PARENT, /* lower inode, parent first */ ++ AuLsc_I_PARENT2, /* copyup dirs */ ++ AuLsc_I_PARENT3, /* copyup wh */ ++ AuLsc_I_CHILD, ++ AuLsc_I_CHILD2, ++ AuLsc_I_End ++}; ++ ++/* to debug easier, do not make them inlined functions */ ++#define MtxMustLock(mtx) AuDebugOn(!mutex_is_locked(mtx)) ++#define IMustLock(i) AuDebugOn(!inode_is_locked(i)) ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline void vfsub_drop_nlink(struct inode *inode) ++{ ++ AuDebugOn(!inode->i_nlink); ++ drop_nlink(inode); ++} ++ ++static inline void vfsub_dead_dir(struct inode *inode) ++{ ++ AuDebugOn(!S_ISDIR(inode->i_mode)); ++ inode->i_flags |= S_DEAD; ++ clear_nlink(inode); ++} ++ ++static inline int vfsub_native_ro(struct inode *inode) ++{ ++ return sb_rdonly(inode->i_sb) ++ || IS_RDONLY(inode) ++ /* || IS_APPEND(inode) */ ++ || IS_IMMUTABLE(inode); ++} ++ ++#ifdef CONFIG_AUFS_BR_FUSE ++int vfsub_test_mntns(struct vfsmount *mnt, struct super_block *h_sb); ++#else ++AuStubInt0(vfsub_test_mntns, struct vfsmount *mnt, struct super_block *h_sb); ++#endif ++ ++int vfsub_sync_filesystem(struct super_block *h_sb, int wait); ++ ++/* ---------------------------------------------------------------------- */ ++ ++int vfsub_update_h_iattr(struct path *h_path, int *did); ++struct file *vfsub_dentry_open(struct path *path, int flags); ++struct file *vfsub_filp_open(const char *path, int oflags, int mode); ++struct au_branch; ++struct vfsub_aopen_args { ++ struct file *file; ++ unsigned int open_flag; ++ umode_t create_mode; ++ struct au_branch *br; ++}; ++int vfsub_atomic_open(struct inode *dir, struct dentry *dentry, ++ struct vfsub_aopen_args *args); ++int vfsub_kern_path(const char *name, unsigned int flags, struct path *path); ++ ++struct dentry *vfsub_lookup_one_len_unlocked(const char *name, ++ struct dentry *parent, int len); ++struct dentry *vfsub_lookup_one_len(const char *name, struct dentry *parent, ++ int len); ++ ++struct vfsub_lkup_one_args { ++ struct dentry **errp; ++ struct qstr *name; ++ struct dentry *parent; ++}; ++ ++static inline struct dentry *vfsub_lkup_one(struct qstr *name, ++ struct dentry *parent) ++{ ++ return vfsub_lookup_one_len(name->name, parent, name->len); ++} ++ ++void vfsub_call_lkup_one(void *args); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline int vfsub_mnt_want_write(struct vfsmount *mnt) ++{ ++ int err; ++ ++ lockdep_off(); ++ err = mnt_want_write(mnt); ++ lockdep_on(); ++ return err; ++} ++ ++static inline void vfsub_mnt_drop_write(struct vfsmount *mnt) ++{ ++ lockdep_off(); ++ mnt_drop_write(mnt); ++ lockdep_on(); ++} ++ ++#if 0 /* reserved */ ++static inline void vfsub_mnt_drop_write_file(struct file *file) ++{ ++ lockdep_off(); ++ mnt_drop_write_file(file); ++ lockdep_on(); ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_hinode; ++struct dentry *vfsub_lock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2); ++void vfsub_unlock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2); ++ ++int vfsub_create(struct inode *dir, struct path *path, int mode, ++ bool want_excl); ++int vfsub_symlink(struct inode *dir, struct path *path, ++ const char *symname); ++int vfsub_mknod(struct inode *dir, struct path *path, int mode, dev_t dev); ++int vfsub_link(struct dentry *src_dentry, struct inode *dir, ++ struct path *path, struct inode **delegated_inode); ++int vfsub_rename(struct inode *src_hdir, struct dentry *src_dentry, ++ struct inode *hdir, struct path *path, ++ struct inode **delegated_inode, unsigned int flags); ++int vfsub_mkdir(struct inode *dir, struct path *path, int mode); ++int vfsub_rmdir(struct inode *dir, struct path *path); ++ ++/* ---------------------------------------------------------------------- */ ++ ++ssize_t vfsub_read_u(struct file *file, char __user *ubuf, size_t count, ++ loff_t *ppos); ++ssize_t vfsub_read_k(struct file *file, void *kbuf, size_t count, ++ loff_t *ppos); ++ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count, ++ loff_t *ppos); ++ssize_t vfsub_write_k(struct file *file, void *kbuf, size_t count, ++ loff_t *ppos); ++int vfsub_flush(struct file *file, fl_owner_t id); ++int vfsub_iterate_dir(struct file *file, struct dir_context *ctx); ++ ++static inline loff_t vfsub_f_size_read(struct file *file) ++{ ++ return i_size_read(file_inode(file)); ++} ++ ++static inline unsigned int vfsub_file_flags(struct file *file) ++{ ++ unsigned int flags; ++ ++ spin_lock(&file->f_lock); ++ flags = file->f_flags; ++ spin_unlock(&file->f_lock); ++ ++ return flags; ++} ++ ++static inline int vfsub_file_execed(struct file *file) ++{ ++ /* todo: direct access f_flags */ ++ return !!(vfsub_file_flags(file) & __FMODE_EXEC); ++} ++ ++#if 0 /* reserved */ ++static inline void vfsub_file_accessed(struct file *h_file) ++{ ++ file_accessed(h_file); ++ vfsub_update_h_iattr(&h_file->f_path, /*did*/NULL); /*ignore*/ ++} ++#endif ++ ++#if 0 /* reserved */ ++static inline void vfsub_touch_atime(struct vfsmount *h_mnt, ++ struct dentry *h_dentry) ++{ ++ struct path h_path = { ++ .dentry = h_dentry, ++ .mnt = h_mnt ++ }; ++ touch_atime(&h_path); ++ vfsub_update_h_iattr(&h_path, /*did*/NULL); /*ignore*/ ++} ++#endif ++ ++static inline int vfsub_update_time(struct inode *h_inode, ++ struct timespec64 *ts, int flags) ++{ ++ return update_time(h_inode, ts, flags); ++ /* no vfsub_update_h_iattr() since we don't have struct path */ ++} ++ ++#ifdef CONFIG_FS_POSIX_ACL ++static inline int vfsub_acl_chmod(struct inode *h_inode, umode_t h_mode) ++{ ++ int err; ++ ++ err = posix_acl_chmod(h_inode, h_mode); ++ if (err == -EOPNOTSUPP) ++ err = 0; ++ return err; ++} ++#else ++AuStubInt0(vfsub_acl_chmod, struct inode *h_inode, umode_t h_mode); ++#endif ++ ++long vfsub_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags); ++long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags); ++ ++static inline long vfsub_truncate(struct path *path, loff_t length) ++{ ++ long err; ++ ++ lockdep_off(); ++ err = vfs_truncate(path, length); ++ lockdep_on(); ++ return err; ++} ++ ++int vfsub_trunc(struct path *h_path, loff_t length, unsigned int attr, ++ struct file *h_file); ++int vfsub_fsync(struct file *file, struct path *path, int datasync); ++ ++/* ++ * re-use branch fs's ioctl(FICLONE) while aufs itself doesn't support such ++ * ioctl. ++ */ ++static inline loff_t vfsub_clone_file_range(struct file *src, struct file *dst, ++ loff_t len) ++{ ++ loff_t err; ++ ++ lockdep_off(); ++ err = vfs_clone_file_range(src, 0, dst, 0, len, /*remap_flags*/0); ++ lockdep_on(); ++ ++ return err; ++} ++ ++/* copy_file_range(2) is a systemcall */ ++static inline ssize_t vfsub_copy_file_range(struct file *src, loff_t src_pos, ++ struct file *dst, loff_t dst_pos, ++ size_t len, unsigned int flags) ++{ ++ ssize_t ssz; ++ ++ lockdep_off(); ++ ssz = vfs_copy_file_range(src, src_pos, dst, dst_pos, len, flags); ++ lockdep_on(); ++ ++ return ssz; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline loff_t vfsub_llseek(struct file *file, loff_t offset, int origin) ++{ ++ loff_t err; ++ ++ lockdep_off(); ++ err = vfs_llseek(file, offset, origin); ++ lockdep_on(); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int vfsub_sio_mkdir(struct inode *dir, struct path *path, int mode); ++int vfsub_sio_rmdir(struct inode *dir, struct path *path); ++int vfsub_sio_notify_change(struct path *path, struct iattr *ia, ++ struct inode **delegated_inode); ++int vfsub_notify_change(struct path *path, struct iattr *ia, ++ struct inode **delegated_inode); ++int vfsub_unlink(struct inode *dir, struct path *path, ++ struct inode **delegated_inode, int force); ++ ++static inline int vfsub_getattr(const struct path *path, struct kstat *st) ++{ ++ return vfs_getattr(path, st, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline int vfsub_setxattr(struct dentry *dentry, const char *name, ++ const void *value, size_t size, int flags) ++{ ++ int err; ++ ++ lockdep_off(); ++ err = vfs_setxattr(dentry, name, value, size, flags); ++ lockdep_on(); ++ ++ return err; ++} ++ ++static inline int vfsub_removexattr(struct dentry *dentry, const char *name) ++{ ++ int err; ++ ++ lockdep_off(); ++ err = vfs_removexattr(dentry, name); ++ lockdep_on(); ++ ++ return err; ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_VFSUB_H__ */ +diff --git a/fs/aufs/wbr_policy.c b/fs/aufs/wbr_policy.c +new file mode 100644 +index 000000000000..a18045b12573 +--- /dev/null ++++ b/fs/aufs/wbr_policy.c +@@ -0,0 +1,817 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * policies for selecting one among multiple writable branches ++ */ ++ ++#include ++#include "aufs.h" ++ ++/* subset of cpup_attr() */ ++static noinline_for_stack ++int au_cpdown_attr(struct path *h_path, struct dentry *h_src) ++{ ++ int err, sbits; ++ struct iattr ia; ++ struct inode *h_isrc; ++ ++ h_isrc = d_inode(h_src); ++ ia.ia_valid = ATTR_FORCE | ATTR_MODE | ATTR_UID | ATTR_GID; ++ ia.ia_mode = h_isrc->i_mode; ++ ia.ia_uid = h_isrc->i_uid; ++ ia.ia_gid = h_isrc->i_gid; ++ sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID)); ++ au_cpup_attr_flags(d_inode(h_path->dentry), h_isrc->i_flags); ++ /* no delegation since it is just created */ ++ err = vfsub_sio_notify_change(h_path, &ia, /*delegated*/NULL); ++ ++ /* is this nfs only? */ ++ if (!err && sbits && au_test_nfs(h_path->dentry->d_sb)) { ++ ia.ia_valid = ATTR_FORCE | ATTR_MODE; ++ ia.ia_mode = h_isrc->i_mode; ++ err = vfsub_sio_notify_change(h_path, &ia, /*delegated*/NULL); ++ } ++ ++ return err; ++} ++ ++#define AuCpdown_PARENT_OPQ 1 ++#define AuCpdown_WHED (1 << 1) ++#define AuCpdown_MADE_DIR (1 << 2) ++#define AuCpdown_DIROPQ (1 << 3) ++#define au_ftest_cpdown(flags, name) ((flags) & AuCpdown_##name) ++#define au_fset_cpdown(flags, name) \ ++ do { (flags) |= AuCpdown_##name; } while (0) ++#define au_fclr_cpdown(flags, name) \ ++ do { (flags) &= ~AuCpdown_##name; } while (0) ++ ++static int au_cpdown_dir_opq(struct dentry *dentry, aufs_bindex_t bdst, ++ unsigned int *flags) ++{ ++ int err; ++ struct dentry *opq_dentry; ++ ++ opq_dentry = au_diropq_create(dentry, bdst); ++ err = PTR_ERR(opq_dentry); ++ if (IS_ERR(opq_dentry)) ++ goto out; ++ dput(opq_dentry); ++ au_fset_cpdown(*flags, DIROPQ); ++ ++out: ++ return err; ++} ++ ++static int au_cpdown_dir_wh(struct dentry *dentry, struct dentry *h_parent, ++ struct inode *dir, aufs_bindex_t bdst) ++{ ++ int err; ++ struct path h_path; ++ struct au_branch *br; ++ ++ br = au_sbr(dentry->d_sb, bdst); ++ h_path.dentry = au_wh_lkup(h_parent, &dentry->d_name, br); ++ err = PTR_ERR(h_path.dentry); ++ if (IS_ERR(h_path.dentry)) ++ goto out; ++ ++ err = 0; ++ if (d_is_positive(h_path.dentry)) { ++ h_path.mnt = au_br_mnt(br); ++ err = au_wh_unlink_dentry(au_h_iptr(dir, bdst), &h_path, ++ dentry); ++ } ++ dput(h_path.dentry); ++ ++out: ++ return err; ++} ++ ++static int au_cpdown_dir(struct dentry *dentry, aufs_bindex_t bdst, ++ struct au_pin *pin, ++ struct dentry *h_parent, void *arg) ++{ ++ int err, rerr; ++ aufs_bindex_t bopq, btop; ++ struct path h_path; ++ struct dentry *parent; ++ struct inode *h_dir, *h_inode, *inode, *dir; ++ unsigned int *flags = arg; ++ ++ btop = au_dbtop(dentry); ++ /* dentry is di-locked */ ++ parent = dget_parent(dentry); ++ dir = d_inode(parent); ++ h_dir = d_inode(h_parent); ++ AuDebugOn(h_dir != au_h_iptr(dir, bdst)); ++ IMustLock(h_dir); ++ ++ err = au_lkup_neg(dentry, bdst, /*wh*/0); ++ if (unlikely(err < 0)) ++ goto out; ++ h_path.dentry = au_h_dptr(dentry, bdst); ++ h_path.mnt = au_sbr_mnt(dentry->d_sb, bdst); ++ err = vfsub_sio_mkdir(au_h_iptr(dir, bdst), &h_path, 0755); ++ if (unlikely(err)) ++ goto out_put; ++ au_fset_cpdown(*flags, MADE_DIR); ++ ++ bopq = au_dbdiropq(dentry); ++ au_fclr_cpdown(*flags, WHED); ++ au_fclr_cpdown(*flags, DIROPQ); ++ if (au_dbwh(dentry) == bdst) ++ au_fset_cpdown(*flags, WHED); ++ if (!au_ftest_cpdown(*flags, PARENT_OPQ) && bopq <= bdst) ++ au_fset_cpdown(*flags, PARENT_OPQ); ++ h_inode = d_inode(h_path.dentry); ++ inode_lock_nested(h_inode, AuLsc_I_CHILD); ++ if (au_ftest_cpdown(*flags, WHED)) { ++ err = au_cpdown_dir_opq(dentry, bdst, flags); ++ if (unlikely(err)) { ++ inode_unlock(h_inode); ++ goto out_dir; ++ } ++ } ++ ++ err = au_cpdown_attr(&h_path, au_h_dptr(dentry, btop)); ++ inode_unlock(h_inode); ++ if (unlikely(err)) ++ goto out_opq; ++ ++ if (au_ftest_cpdown(*flags, WHED)) { ++ err = au_cpdown_dir_wh(dentry, h_parent, dir, bdst); ++ if (unlikely(err)) ++ goto out_opq; ++ } ++ ++ inode = d_inode(dentry); ++ if (au_ibbot(inode) < bdst) ++ au_set_ibbot(inode, bdst); ++ au_set_h_iptr(inode, bdst, au_igrab(h_inode), ++ au_hi_flags(inode, /*isdir*/1)); ++ au_fhsm_wrote(dentry->d_sb, bdst, /*force*/0); ++ goto out; /* success */ ++ ++ /* revert */ ++out_opq: ++ if (au_ftest_cpdown(*flags, DIROPQ)) { ++ inode_lock_nested(h_inode, AuLsc_I_CHILD); ++ rerr = au_diropq_remove(dentry, bdst); ++ inode_unlock(h_inode); ++ if (unlikely(rerr)) { ++ AuIOErr("failed removing diropq for %pd b%d (%d)\n", ++ dentry, bdst, rerr); ++ err = -EIO; ++ goto out; ++ } ++ } ++out_dir: ++ if (au_ftest_cpdown(*flags, MADE_DIR)) { ++ rerr = vfsub_sio_rmdir(au_h_iptr(dir, bdst), &h_path); ++ if (unlikely(rerr)) { ++ AuIOErr("failed removing %pd b%d (%d)\n", ++ dentry, bdst, rerr); ++ err = -EIO; ++ } ++ } ++out_put: ++ au_set_h_dptr(dentry, bdst, NULL); ++ if (au_dbbot(dentry) == bdst) ++ au_update_dbbot(dentry); ++out: ++ dput(parent); ++ return err; ++} ++ ++int au_cpdown_dirs(struct dentry *dentry, aufs_bindex_t bdst) ++{ ++ int err; ++ unsigned int flags; ++ ++ flags = 0; ++ err = au_cp_dirs(dentry, bdst, au_cpdown_dir, &flags); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policies for create */ ++ ++int au_wbr_nonopq(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ int err, i, j, ndentry; ++ aufs_bindex_t bopq; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries, *parent, *d; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ parent = dget_parent(dentry); ++ err = au_dcsub_pages_rev_aufs(&dpages, parent, /*do_include*/0); ++ if (unlikely(err)) ++ goto out_free; ++ ++ err = bindex; ++ for (i = 0; i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ ndentry = dpage->ndentry; ++ for (j = 0; j < ndentry; j++) { ++ d = dentries[j]; ++ di_read_lock_parent2(d, !AuLock_IR); ++ bopq = au_dbdiropq(d); ++ di_read_unlock(d, !AuLock_IR); ++ if (bopq >= 0 && bopq < err) ++ err = bopq; ++ } ++ } ++ ++out_free: ++ dput(parent); ++ au_dpages_free(&dpages); ++out: ++ return err; ++} ++ ++static int au_wbr_bu(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ for (; bindex >= 0; bindex--) ++ if (!au_br_rdonly(au_sbr(sb, bindex))) ++ return bindex; ++ return -EROFS; ++} ++ ++/* top down parent */ ++static int au_wbr_create_tdp(struct dentry *dentry, ++ unsigned int flags __maybe_unused) ++{ ++ int err; ++ aufs_bindex_t btop, bindex; ++ struct super_block *sb; ++ struct dentry *parent, *h_parent; ++ ++ sb = dentry->d_sb; ++ btop = au_dbtop(dentry); ++ err = btop; ++ if (!au_br_rdonly(au_sbr(sb, btop))) ++ goto out; ++ ++ err = -EROFS; ++ parent = dget_parent(dentry); ++ for (bindex = au_dbtop(parent); bindex < btop; bindex++) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || d_is_negative(h_parent)) ++ continue; ++ ++ if (!au_br_rdonly(au_sbr(sb, bindex))) { ++ err = bindex; ++ break; ++ } ++ } ++ dput(parent); ++ ++ /* bottom up here */ ++ if (unlikely(err < 0)) { ++ err = au_wbr_bu(sb, btop - 1); ++ if (err >= 0) ++ err = au_wbr_nonopq(dentry, err); ++ } ++ ++out: ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* an exception for the policy other than tdp */ ++static int au_wbr_create_exp(struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t bwh, bdiropq; ++ struct dentry *parent; ++ ++ err = -1; ++ bwh = au_dbwh(dentry); ++ parent = dget_parent(dentry); ++ bdiropq = au_dbdiropq(parent); ++ if (bwh >= 0) { ++ if (bdiropq >= 0) ++ err = min(bdiropq, bwh); ++ else ++ err = bwh; ++ AuDbg("%d\n", err); ++ } else if (bdiropq >= 0) { ++ err = bdiropq; ++ AuDbg("%d\n", err); ++ } ++ dput(parent); ++ ++ if (err >= 0) ++ err = au_wbr_nonopq(dentry, err); ++ ++ if (err >= 0 && au_br_rdonly(au_sbr(dentry->d_sb, err))) ++ err = -1; ++ ++ AuDbg("%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* round robin */ ++static int au_wbr_create_init_rr(struct super_block *sb) ++{ ++ int err; ++ ++ err = au_wbr_bu(sb, au_sbbot(sb)); ++ atomic_set(&au_sbi(sb)->si_wbr_rr_next, -err); /* less important */ ++ /* smp_mb(); */ ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++static int au_wbr_create_rr(struct dentry *dentry, unsigned int flags) ++{ ++ int err, nbr; ++ unsigned int u; ++ aufs_bindex_t bindex, bbot; ++ struct super_block *sb; ++ atomic_t *next; ++ ++ err = au_wbr_create_exp(dentry); ++ if (err >= 0) ++ goto out; ++ ++ sb = dentry->d_sb; ++ next = &au_sbi(sb)->si_wbr_rr_next; ++ bbot = au_sbbot(sb); ++ nbr = bbot + 1; ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ if (!au_ftest_wbr(flags, DIR)) { ++ err = atomic_dec_return(next) + 1; ++ /* modulo for 0 is meaningless */ ++ if (unlikely(!err)) ++ err = atomic_dec_return(next) + 1; ++ } else ++ err = atomic_read(next); ++ AuDbg("%d\n", err); ++ u = err; ++ err = u % nbr; ++ AuDbg("%d\n", err); ++ if (!au_br_rdonly(au_sbr(sb, err))) ++ break; ++ err = -EROFS; ++ } ++ ++ if (err >= 0) ++ err = au_wbr_nonopq(dentry, err); ++ ++out: ++ AuDbg("%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* most free space */ ++static void au_mfs(struct dentry *dentry, struct dentry *parent) ++{ ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_wbr_mfs *mfs; ++ struct dentry *h_parent; ++ aufs_bindex_t bindex, bbot; ++ int err; ++ unsigned long long b, bavail; ++ struct path h_path; ++ /* reduce the stack usage */ ++ struct kstatfs *st; ++ ++ st = kmalloc(sizeof(*st), GFP_NOFS); ++ if (unlikely(!st)) { ++ AuWarn1("failed updating mfs(%d), ignored\n", -ENOMEM); ++ return; ++ } ++ ++ bavail = 0; ++ sb = dentry->d_sb; ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ MtxMustLock(&mfs->mfs_lock); ++ mfs->mfs_bindex = -EROFS; ++ mfs->mfsrr_bytes = 0; ++ if (!parent) { ++ bindex = 0; ++ bbot = au_sbbot(sb); ++ } else { ++ bindex = au_dbtop(parent); ++ bbot = au_dbtaildir(parent); ++ } ++ ++ for (; bindex <= bbot; bindex++) { ++ if (parent) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || d_is_negative(h_parent)) ++ continue; ++ } ++ br = au_sbr(sb, bindex); ++ if (au_br_rdonly(br)) ++ continue; ++ ++ /* sb->s_root for NFS is unreliable */ ++ h_path.mnt = au_br_mnt(br); ++ h_path.dentry = h_path.mnt->mnt_root; ++ err = vfs_statfs(&h_path, st); ++ if (unlikely(err)) { ++ AuWarn1("failed statfs, b%d, %d\n", bindex, err); ++ continue; ++ } ++ ++ /* when the available size is equal, select the lower one */ ++ BUILD_BUG_ON(sizeof(b) < sizeof(st->f_bavail) ++ || sizeof(b) < sizeof(st->f_bsize)); ++ b = st->f_bavail * st->f_bsize; ++ br->br_wbr->wbr_bytes = b; ++ if (b >= bavail) { ++ bavail = b; ++ mfs->mfs_bindex = bindex; ++ mfs->mfs_jiffy = jiffies; ++ } ++ } ++ ++ mfs->mfsrr_bytes = bavail; ++ AuDbg("b%d\n", mfs->mfs_bindex); ++ au_kfree_rcu(st); ++} ++ ++static int au_wbr_create_mfs(struct dentry *dentry, unsigned int flags) ++{ ++ int err; ++ struct dentry *parent; ++ struct super_block *sb; ++ struct au_wbr_mfs *mfs; ++ ++ err = au_wbr_create_exp(dentry); ++ if (err >= 0) ++ goto out; ++ ++ sb = dentry->d_sb; ++ parent = NULL; ++ if (au_ftest_wbr(flags, PARENT)) ++ parent = dget_parent(dentry); ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ mutex_lock(&mfs->mfs_lock); ++ if (time_after(jiffies, mfs->mfs_jiffy + mfs->mfs_expire) ++ || mfs->mfs_bindex < 0 ++ || au_br_rdonly(au_sbr(sb, mfs->mfs_bindex))) ++ au_mfs(dentry, parent); ++ mutex_unlock(&mfs->mfs_lock); ++ err = mfs->mfs_bindex; ++ dput(parent); ++ ++ if (err >= 0) ++ err = au_wbr_nonopq(dentry, err); ++ ++out: ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++static int au_wbr_create_init_mfs(struct super_block *sb) ++{ ++ struct au_wbr_mfs *mfs; ++ ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ mutex_init(&mfs->mfs_lock); ++ mfs->mfs_jiffy = 0; ++ mfs->mfs_bindex = -EROFS; ++ ++ return 0; ++} ++ ++static int au_wbr_create_fin_mfs(struct super_block *sb __maybe_unused) ++{ ++ mutex_destroy(&au_sbi(sb)->si_wbr_mfs.mfs_lock); ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* top down regardless parent, and then mfs */ ++static int au_wbr_create_tdmfs(struct dentry *dentry, ++ unsigned int flags __maybe_unused) ++{ ++ int err; ++ aufs_bindex_t bwh, btail, bindex, bfound, bmfs; ++ unsigned long long watermark; ++ struct super_block *sb; ++ struct au_wbr_mfs *mfs; ++ struct au_branch *br; ++ struct dentry *parent; ++ ++ sb = dentry->d_sb; ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ mutex_lock(&mfs->mfs_lock); ++ if (time_after(jiffies, mfs->mfs_jiffy + mfs->mfs_expire) ++ || mfs->mfs_bindex < 0) ++ au_mfs(dentry, /*parent*/NULL); ++ watermark = mfs->mfsrr_watermark; ++ bmfs = mfs->mfs_bindex; ++ mutex_unlock(&mfs->mfs_lock); ++ ++ /* another style of au_wbr_create_exp() */ ++ bwh = au_dbwh(dentry); ++ parent = dget_parent(dentry); ++ btail = au_dbtaildir(parent); ++ if (bwh >= 0 && bwh < btail) ++ btail = bwh; ++ ++ err = au_wbr_nonopq(dentry, btail); ++ if (unlikely(err < 0)) ++ goto out; ++ btail = err; ++ bfound = -1; ++ for (bindex = 0; bindex <= btail; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_rdonly(br)) ++ continue; ++ if (br->br_wbr->wbr_bytes > watermark) { ++ bfound = bindex; ++ break; ++ } ++ } ++ err = bfound; ++ if (err < 0) ++ err = bmfs; ++ ++out: ++ dput(parent); ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* most free space and then round robin */ ++static int au_wbr_create_mfsrr(struct dentry *dentry, unsigned int flags) ++{ ++ int err; ++ struct au_wbr_mfs *mfs; ++ ++ err = au_wbr_create_mfs(dentry, flags); ++ if (err >= 0) { ++ mfs = &au_sbi(dentry->d_sb)->si_wbr_mfs; ++ mutex_lock(&mfs->mfs_lock); ++ if (mfs->mfsrr_bytes < mfs->mfsrr_watermark) ++ err = au_wbr_create_rr(dentry, flags); ++ mutex_unlock(&mfs->mfs_lock); ++ } ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++static int au_wbr_create_init_mfsrr(struct super_block *sb) ++{ ++ int err; ++ ++ au_wbr_create_init_mfs(sb); /* ignore */ ++ err = au_wbr_create_init_rr(sb); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* top down parent and most free space */ ++static int au_wbr_create_pmfs(struct dentry *dentry, unsigned int flags) ++{ ++ int err, e2; ++ unsigned long long b; ++ aufs_bindex_t bindex, btop, bbot; ++ struct super_block *sb; ++ struct dentry *parent, *h_parent; ++ struct au_branch *br; ++ ++ err = au_wbr_create_tdp(dentry, flags); ++ if (unlikely(err < 0)) ++ goto out; ++ parent = dget_parent(dentry); ++ btop = au_dbtop(parent); ++ bbot = au_dbtaildir(parent); ++ if (btop == bbot) ++ goto out_parent; /* success */ ++ ++ e2 = au_wbr_create_mfs(dentry, flags); ++ if (e2 < 0) ++ goto out_parent; /* success */ ++ ++ /* when the available size is equal, select upper one */ ++ sb = dentry->d_sb; ++ br = au_sbr(sb, err); ++ b = br->br_wbr->wbr_bytes; ++ AuDbg("b%d, %llu\n", err, b); ++ ++ for (bindex = btop; bindex <= bbot; bindex++) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || d_is_negative(h_parent)) ++ continue; ++ ++ br = au_sbr(sb, bindex); ++ if (!au_br_rdonly(br) && br->br_wbr->wbr_bytes > b) { ++ b = br->br_wbr->wbr_bytes; ++ err = bindex; ++ AuDbg("b%d, %llu\n", err, b); ++ } ++ } ++ ++ if (err >= 0) ++ err = au_wbr_nonopq(dentry, err); ++ ++out_parent: ++ dput(parent); ++out: ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * - top down parent ++ * - most free space with parent ++ * - most free space round-robin regardless parent ++ */ ++static int au_wbr_create_pmfsrr(struct dentry *dentry, unsigned int flags) ++{ ++ int err; ++ unsigned long long watermark; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_wbr_mfs *mfs; ++ ++ err = au_wbr_create_pmfs(dentry, flags | AuWbr_PARENT); ++ if (unlikely(err < 0)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ br = au_sbr(sb, err); ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ mutex_lock(&mfs->mfs_lock); ++ watermark = mfs->mfsrr_watermark; ++ mutex_unlock(&mfs->mfs_lock); ++ if (br->br_wbr->wbr_bytes < watermark) ++ /* regardless the parent dir */ ++ err = au_wbr_create_mfsrr(dentry, flags); ++ ++out: ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policies for copyup */ ++ ++/* top down parent */ ++static int au_wbr_copyup_tdp(struct dentry *dentry) ++{ ++ return au_wbr_create_tdp(dentry, /*flags, anything is ok*/0); ++} ++ ++/* bottom up parent */ ++static int au_wbr_copyup_bup(struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t bindex, btop; ++ struct dentry *parent, *h_parent; ++ struct super_block *sb; ++ ++ err = -EROFS; ++ sb = dentry->d_sb; ++ parent = dget_parent(dentry); ++ btop = au_dbtop(parent); ++ for (bindex = au_dbtop(dentry); bindex >= btop; bindex--) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || d_is_negative(h_parent)) ++ continue; ++ ++ if (!au_br_rdonly(au_sbr(sb, bindex))) { ++ err = bindex; ++ break; ++ } ++ } ++ dput(parent); ++ ++ /* bottom up here */ ++ if (unlikely(err < 0)) ++ err = au_wbr_bu(sb, btop - 1); ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* bottom up */ ++int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t btop) ++{ ++ int err; ++ ++ err = au_wbr_bu(dentry->d_sb, btop); ++ AuDbg("b%d\n", err); ++ if (err > btop) ++ err = au_wbr_nonopq(dentry, err); ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++static int au_wbr_copyup_bu(struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t btop; ++ ++ btop = au_dbtop(dentry); ++ err = au_wbr_do_copyup_bu(dentry, btop); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_wbr_copyup_operations au_wbr_copyup_ops[] = { ++ [AuWbrCopyup_TDP] = { ++ .copyup = au_wbr_copyup_tdp ++ }, ++ [AuWbrCopyup_BUP] = { ++ .copyup = au_wbr_copyup_bup ++ }, ++ [AuWbrCopyup_BU] = { ++ .copyup = au_wbr_copyup_bu ++ } ++}; ++ ++struct au_wbr_create_operations au_wbr_create_ops[] = { ++ [AuWbrCreate_TDP] = { ++ .create = au_wbr_create_tdp ++ }, ++ [AuWbrCreate_RR] = { ++ .create = au_wbr_create_rr, ++ .init = au_wbr_create_init_rr ++ }, ++ [AuWbrCreate_MFS] = { ++ .create = au_wbr_create_mfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_MFSV] = { ++ .create = au_wbr_create_mfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_MFSRR] = { ++ .create = au_wbr_create_mfsrr, ++ .init = au_wbr_create_init_mfsrr, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_MFSRRV] = { ++ .create = au_wbr_create_mfsrr, ++ .init = au_wbr_create_init_mfsrr, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_TDMFS] = { ++ .create = au_wbr_create_tdmfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_TDMFSV] = { ++ .create = au_wbr_create_tdmfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_PMFS] = { ++ .create = au_wbr_create_pmfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_PMFSV] = { ++ .create = au_wbr_create_pmfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_PMFSRR] = { ++ .create = au_wbr_create_pmfsrr, ++ .init = au_wbr_create_init_mfsrr, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_PMFSRRV] = { ++ .create = au_wbr_create_pmfsrr, ++ .init = au_wbr_create_init_mfsrr, ++ .fin = au_wbr_create_fin_mfs ++ } ++}; +diff --git a/fs/aufs/whout.c b/fs/aufs/whout.c +new file mode 100644 +index 000000000000..9363954c4b06 +--- /dev/null ++++ b/fs/aufs/whout.c +@@ -0,0 +1,1049 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * whiteout for logical deletion and opaque directory ++ */ ++ ++#include "aufs.h" ++ ++#define WH_MASK 0444 ++ ++/* ++ * If a directory contains this file, then it is opaque. We start with the ++ * .wh. flag so that it is blocked by lookup. ++ */ ++static struct qstr diropq_name = QSTR_INIT(AUFS_WH_DIROPQ, ++ sizeof(AUFS_WH_DIROPQ) - 1); ++ ++/* ++ * generate whiteout name, which is NOT terminated by NULL. ++ * @name: original d_name.name ++ * @len: original d_name.len ++ * @wh: whiteout qstr ++ * returns zero when succeeds, otherwise error. ++ * succeeded value as wh->name should be freed by kfree(). ++ */ ++int au_wh_name_alloc(struct qstr *wh, const struct qstr *name) ++{ ++ char *p; ++ ++ if (unlikely(name->len > PATH_MAX - AUFS_WH_PFX_LEN)) ++ return -ENAMETOOLONG; ++ ++ wh->len = name->len + AUFS_WH_PFX_LEN; ++ p = kmalloc(wh->len, GFP_NOFS); ++ wh->name = p; ++ if (p) { ++ memcpy(p, AUFS_WH_PFX, AUFS_WH_PFX_LEN); ++ memcpy(p + AUFS_WH_PFX_LEN, name->name, name->len); ++ /* smp_mb(); */ ++ return 0; ++ } ++ return -ENOMEM; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * test if the @wh_name exists under @h_parent. ++ * @try_sio specifies the necessary of super-io. ++ */ ++int au_wh_test(struct dentry *h_parent, struct qstr *wh_name, int try_sio) ++{ ++ int err; ++ struct dentry *wh_dentry; ++ ++ if (!try_sio) ++ wh_dentry = vfsub_lkup_one(wh_name, h_parent); ++ else ++ wh_dentry = au_sio_lkup_one(wh_name, h_parent); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) { ++ if (err == -ENAMETOOLONG) ++ err = 0; ++ goto out; ++ } ++ ++ err = 0; ++ if (d_is_negative(wh_dentry)) ++ goto out_wh; /* success */ ++ ++ err = 1; ++ if (d_is_reg(wh_dentry)) ++ goto out_wh; /* success */ ++ ++ err = -EIO; ++ AuIOErr("%pd Invalid whiteout entry type 0%o.\n", ++ wh_dentry, d_inode(wh_dentry)->i_mode); ++ ++out_wh: ++ dput(wh_dentry); ++out: ++ return err; ++} ++ ++/* ++ * test if the @h_dentry sets opaque or not. ++ */ ++int au_diropq_test(struct dentry *h_dentry) ++{ ++ int err; ++ struct inode *h_dir; ++ ++ h_dir = d_inode(h_dentry); ++ err = au_wh_test(h_dentry, &diropq_name, ++ au_test_h_perm_sio(h_dir, MAY_EXEC)); ++ return err; ++} ++ ++/* ++ * returns a negative dentry whose name is unique and temporary. ++ */ ++struct dentry *au_whtmp_lkup(struct dentry *h_parent, struct au_branch *br, ++ struct qstr *prefix) ++{ ++ struct dentry *dentry; ++ int i; ++ char defname[NAME_MAX - AUFS_MAX_NAMELEN + DNAME_INLINE_LEN + 1], ++ *name, *p; ++ /* strict atomic_t is unnecessary here */ ++ static unsigned short cnt; ++ struct qstr qs; ++ ++ BUILD_BUG_ON(sizeof(cnt) * 2 > AUFS_WH_TMP_LEN); ++ ++ name = defname; ++ qs.len = sizeof(defname) - DNAME_INLINE_LEN + prefix->len - 1; ++ if (unlikely(prefix->len > DNAME_INLINE_LEN)) { ++ dentry = ERR_PTR(-ENAMETOOLONG); ++ if (unlikely(qs.len > NAME_MAX)) ++ goto out; ++ dentry = ERR_PTR(-ENOMEM); ++ name = kmalloc(qs.len + 1, GFP_NOFS); ++ if (unlikely(!name)) ++ goto out; ++ } ++ ++ /* doubly whiteout-ed */ ++ memcpy(name, AUFS_WH_PFX AUFS_WH_PFX, AUFS_WH_PFX_LEN * 2); ++ p = name + AUFS_WH_PFX_LEN * 2; ++ memcpy(p, prefix->name, prefix->len); ++ p += prefix->len; ++ *p++ = '.'; ++ AuDebugOn(name + qs.len + 1 - p <= AUFS_WH_TMP_LEN); ++ ++ qs.name = name; ++ for (i = 0; i < 3; i++) { ++ sprintf(p, "%.*x", AUFS_WH_TMP_LEN, cnt++); ++ dentry = au_sio_lkup_one(&qs, h_parent); ++ if (IS_ERR(dentry) || d_is_negative(dentry)) ++ goto out_name; ++ dput(dentry); ++ } ++ /* pr_warn("could not get random name\n"); */ ++ dentry = ERR_PTR(-EEXIST); ++ AuDbg("%.*s\n", AuLNPair(&qs)); ++ BUG(); ++ ++out_name: ++ if (name != defname) ++ au_kfree_try_rcu(name); ++out: ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++/* ++ * rename the @h_dentry on @br to the whiteouted temporary name. ++ */ ++int au_whtmp_ren(struct dentry *h_dentry, struct au_branch *br) ++{ ++ int err; ++ struct path h_path = { ++ .mnt = au_br_mnt(br) ++ }; ++ struct inode *h_dir, *delegated; ++ struct dentry *h_parent; ++ ++ h_parent = h_dentry->d_parent; /* dir inode is locked */ ++ h_dir = d_inode(h_parent); ++ IMustLock(h_dir); ++ ++ h_path.dentry = au_whtmp_lkup(h_parent, br, &h_dentry->d_name); ++ err = PTR_ERR(h_path.dentry); ++ if (IS_ERR(h_path.dentry)) ++ goto out; ++ ++ /* under the same dir, no need to lock_rename() */ ++ delegated = NULL; ++ err = vfsub_rename(h_dir, h_dentry, h_dir, &h_path, &delegated, ++ /*flags*/0); ++ AuTraceErr(err); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal rename\n"); ++ iput(delegated); ++ } ++ dput(h_path.dentry); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * functions for removing a whiteout ++ */ ++ ++static int do_unlink_wh(struct inode *h_dir, struct path *h_path) ++{ ++ int err, force; ++ struct inode *delegated; ++ ++ /* ++ * forces superio when the dir has a sticky bit. ++ * this may be a violation of unix fs semantics. ++ */ ++ force = (h_dir->i_mode & S_ISVTX) ++ && !uid_eq(current_fsuid(), d_inode(h_path->dentry)->i_uid); ++ delegated = NULL; ++ err = vfsub_unlink(h_dir, h_path, &delegated, force); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ return err; ++} ++ ++int au_wh_unlink_dentry(struct inode *h_dir, struct path *h_path, ++ struct dentry *dentry) ++{ ++ int err; ++ ++ err = do_unlink_wh(h_dir, h_path); ++ if (!err && dentry) ++ au_set_dbwh(dentry, -1); ++ ++ return err; ++} ++ ++static int unlink_wh_name(struct dentry *h_parent, struct qstr *wh, ++ struct au_branch *br) ++{ ++ int err; ++ struct path h_path = { ++ .mnt = au_br_mnt(br) ++ }; ++ ++ err = 0; ++ h_path.dentry = vfsub_lkup_one(wh, h_parent); ++ if (IS_ERR(h_path.dentry)) ++ err = PTR_ERR(h_path.dentry); ++ else { ++ if (d_is_reg(h_path.dentry)) ++ err = do_unlink_wh(d_inode(h_parent), &h_path); ++ dput(h_path.dentry); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * initialize/clean whiteout for a branch ++ */ ++ ++static void au_wh_clean(struct inode *h_dir, struct path *whpath, ++ const int isdir) ++{ ++ int err; ++ struct inode *delegated; ++ ++ if (d_is_negative(whpath->dentry)) ++ return; ++ ++ if (isdir) ++ err = vfsub_rmdir(h_dir, whpath); ++ else { ++ delegated = NULL; ++ err = vfsub_unlink(h_dir, whpath, &delegated, /*force*/0); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ } ++ if (unlikely(err)) ++ pr_warn("failed removing %pd (%d), ignored.\n", ++ whpath->dentry, err); ++} ++ ++static int test_linkable(struct dentry *h_root) ++{ ++ struct inode *h_dir = d_inode(h_root); ++ ++ if (h_dir->i_op->link) ++ return 0; ++ ++ pr_err("%pd (%s) doesn't support link(2), use noplink and rw+nolwh\n", ++ h_root, au_sbtype(h_root->d_sb)); ++ return -ENOSYS; /* the branch doesn't have its ->link() */ ++} ++ ++/* todo: should this mkdir be done in /sbin/mount.aufs helper? */ ++static int au_whdir(struct inode *h_dir, struct path *path) ++{ ++ int err; ++ ++ err = -EEXIST; ++ if (d_is_negative(path->dentry)) { ++ int mode = 0700; ++ ++ if (au_test_nfs(path->dentry->d_sb)) ++ mode |= 0111; ++ err = vfsub_mkdir(h_dir, path, mode); ++ } else if (d_is_dir(path->dentry)) ++ err = 0; ++ else ++ pr_err("unknown %pd exists\n", path->dentry); ++ ++ return err; ++} ++ ++struct au_wh_base { ++ const struct qstr *name; ++ struct dentry *dentry; ++}; ++ ++static void au_wh_init_ro(struct inode *h_dir, struct au_wh_base base[], ++ struct path *h_path) ++{ ++ h_path->dentry = base[AuBrWh_BASE].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/0); ++ h_path->dentry = base[AuBrWh_PLINK].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++ h_path->dentry = base[AuBrWh_ORPH].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++} ++ ++/* ++ * returns tri-state, ++ * minus: error, caller should print the message ++ * zero: success ++ * plus: error, caller should NOT print the message ++ */ ++static int au_wh_init_rw_nolink(struct dentry *h_root, struct au_wbr *wbr, ++ int do_plink, struct au_wh_base base[], ++ struct path *h_path) ++{ ++ int err; ++ struct inode *h_dir; ++ ++ h_dir = d_inode(h_root); ++ h_path->dentry = base[AuBrWh_BASE].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/0); ++ h_path->dentry = base[AuBrWh_PLINK].dentry; ++ if (do_plink) { ++ err = test_linkable(h_root); ++ if (unlikely(err)) { ++ err = 1; ++ goto out; ++ } ++ ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_plink = dget(base[AuBrWh_PLINK].dentry); ++ } else ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++ h_path->dentry = base[AuBrWh_ORPH].dentry; ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_orph = dget(base[AuBrWh_ORPH].dentry); ++ ++out: ++ return err; ++} ++ ++/* ++ * for the moment, aufs supports the branch filesystem which does not support ++ * link(2). testing on FAT which does not support i_op->setattr() fully either, ++ * copyup failed. finally, such filesystem will not be used as the writable ++ * branch. ++ * ++ * returns tri-state, see above. ++ */ ++static int au_wh_init_rw(struct dentry *h_root, struct au_wbr *wbr, ++ int do_plink, struct au_wh_base base[], ++ struct path *h_path) ++{ ++ int err; ++ struct inode *h_dir; ++ ++ WbrWhMustWriteLock(wbr); ++ ++ err = test_linkable(h_root); ++ if (unlikely(err)) { ++ err = 1; ++ goto out; ++ } ++ ++ /* ++ * todo: should this create be done in /sbin/mount.aufs helper? ++ */ ++ err = -EEXIST; ++ h_dir = d_inode(h_root); ++ if (d_is_negative(base[AuBrWh_BASE].dentry)) { ++ h_path->dentry = base[AuBrWh_BASE].dentry; ++ err = vfsub_create(h_dir, h_path, WH_MASK, /*want_excl*/true); ++ } else if (d_is_reg(base[AuBrWh_BASE].dentry)) ++ err = 0; ++ else ++ pr_err("unknown %pd2 exists\n", base[AuBrWh_BASE].dentry); ++ if (unlikely(err)) ++ goto out; ++ ++ h_path->dentry = base[AuBrWh_PLINK].dentry; ++ if (do_plink) { ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_plink = dget(base[AuBrWh_PLINK].dentry); ++ } else ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++ wbr->wbr_whbase = dget(base[AuBrWh_BASE].dentry); ++ ++ h_path->dentry = base[AuBrWh_ORPH].dentry; ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_orph = dget(base[AuBrWh_ORPH].dentry); ++ ++out: ++ return err; ++} ++ ++/* ++ * initialize the whiteout base file/dir for @br. ++ */ ++int au_wh_init(struct au_branch *br, struct super_block *sb) ++{ ++ int err, i; ++ const unsigned char do_plink ++ = !!au_opt_test(au_mntflags(sb), PLINK); ++ struct inode *h_dir; ++ struct path path = br->br_path; ++ struct dentry *h_root = path.dentry; ++ struct au_wbr *wbr = br->br_wbr; ++ static const struct qstr base_name[] = { ++ [AuBrWh_BASE] = QSTR_INIT(AUFS_BASE_NAME, ++ sizeof(AUFS_BASE_NAME) - 1), ++ [AuBrWh_PLINK] = QSTR_INIT(AUFS_PLINKDIR_NAME, ++ sizeof(AUFS_PLINKDIR_NAME) - 1), ++ [AuBrWh_ORPH] = QSTR_INIT(AUFS_ORPHDIR_NAME, ++ sizeof(AUFS_ORPHDIR_NAME) - 1) ++ }; ++ struct au_wh_base base[] = { ++ [AuBrWh_BASE] = { ++ .name = base_name + AuBrWh_BASE, ++ .dentry = NULL ++ }, ++ [AuBrWh_PLINK] = { ++ .name = base_name + AuBrWh_PLINK, ++ .dentry = NULL ++ }, ++ [AuBrWh_ORPH] = { ++ .name = base_name + AuBrWh_ORPH, ++ .dentry = NULL ++ } ++ }; ++ ++ if (wbr) ++ WbrWhMustWriteLock(wbr); ++ ++ for (i = 0; i < AuBrWh_Last; i++) { ++ /* doubly whiteouted */ ++ struct dentry *d; ++ ++ d = au_wh_lkup(h_root, (void *)base[i].name, br); ++ err = PTR_ERR(d); ++ if (IS_ERR(d)) ++ goto out; ++ ++ base[i].dentry = d; ++ AuDebugOn(wbr ++ && wbr->wbr_wh[i] ++ && wbr->wbr_wh[i] != base[i].dentry); ++ } ++ ++ if (wbr) ++ for (i = 0; i < AuBrWh_Last; i++) { ++ dput(wbr->wbr_wh[i]); ++ wbr->wbr_wh[i] = NULL; ++ } ++ ++ err = 0; ++ if (!au_br_writable(br->br_perm)) { ++ h_dir = d_inode(h_root); ++ au_wh_init_ro(h_dir, base, &path); ++ } else if (!au_br_wh_linkable(br->br_perm)) { ++ err = au_wh_init_rw_nolink(h_root, wbr, do_plink, base, &path); ++ if (err > 0) ++ goto out; ++ else if (err) ++ goto out_err; ++ } else { ++ err = au_wh_init_rw(h_root, wbr, do_plink, base, &path); ++ if (err > 0) ++ goto out; ++ else if (err) ++ goto out_err; ++ } ++ goto out; /* success */ ++ ++out_err: ++ pr_err("an error(%d) on the writable branch %pd(%s)\n", ++ err, h_root, au_sbtype(h_root->d_sb)); ++out: ++ for (i = 0; i < AuBrWh_Last; i++) ++ dput(base[i].dentry); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * whiteouts are all hard-linked usually. ++ * when its link count reaches a ceiling, we create a new whiteout base ++ * asynchronously. ++ */ ++ ++struct reinit_br_wh { ++ struct super_block *sb; ++ struct au_branch *br; ++}; ++ ++static void reinit_br_wh(void *arg) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct path h_path; ++ struct reinit_br_wh *a = arg; ++ struct au_wbr *wbr; ++ struct inode *dir, *delegated; ++ struct dentry *h_root; ++ struct au_hinode *hdir; ++ ++ err = 0; ++ wbr = a->br->br_wbr; ++ /* big aufs lock */ ++ si_noflush_write_lock(a->sb); ++ if (!au_br_writable(a->br->br_perm)) ++ goto out; ++ bindex = au_br_index(a->sb, a->br->br_id); ++ if (unlikely(bindex < 0)) ++ goto out; ++ ++ di_read_lock_parent(a->sb->s_root, AuLock_IR); ++ dir = d_inode(a->sb->s_root); ++ hdir = au_hi(dir, bindex); ++ h_root = au_h_dptr(a->sb->s_root, bindex); ++ AuDebugOn(h_root != au_br_dentry(a->br)); ++ ++ au_hn_inode_lock_nested(hdir, AuLsc_I_PARENT); ++ wbr_wh_write_lock(wbr); ++ err = au_h_verify(wbr->wbr_whbase, au_opt_udba(a->sb), hdir->hi_inode, ++ h_root, a->br); ++ if (!err) { ++ h_path.dentry = wbr->wbr_whbase; ++ h_path.mnt = au_br_mnt(a->br); ++ delegated = NULL; ++ err = vfsub_unlink(hdir->hi_inode, &h_path, &delegated, ++ /*force*/0); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ } else { ++ pr_warn("%pd is moved, ignored\n", wbr->wbr_whbase); ++ err = 0; ++ } ++ dput(wbr->wbr_whbase); ++ wbr->wbr_whbase = NULL; ++ if (!err) ++ err = au_wh_init(a->br, a->sb); ++ wbr_wh_write_unlock(wbr); ++ au_hn_inode_unlock(hdir); ++ di_read_unlock(a->sb->s_root, AuLock_IR); ++ if (!err) ++ au_fhsm_wrote(a->sb, bindex, /*force*/0); ++ ++out: ++ if (wbr) ++ atomic_dec(&wbr->wbr_wh_running); ++ au_lcnt_dec(&a->br->br_count); ++ si_write_unlock(a->sb); ++ au_nwt_done(&au_sbi(a->sb)->si_nowait); ++ au_kfree_rcu(a); ++ if (unlikely(err)) ++ AuIOErr("err %d\n", err); ++} ++ ++static void kick_reinit_br_wh(struct super_block *sb, struct au_branch *br) ++{ ++ int do_dec, wkq_err; ++ struct reinit_br_wh *arg; ++ ++ do_dec = 1; ++ if (atomic_inc_return(&br->br_wbr->wbr_wh_running) != 1) ++ goto out; ++ ++ /* ignore ENOMEM */ ++ arg = kmalloc(sizeof(*arg), GFP_NOFS); ++ if (arg) { ++ /* ++ * dec(wh_running), kfree(arg) and dec(br_count) ++ * in reinit function ++ */ ++ arg->sb = sb; ++ arg->br = br; ++ au_lcnt_inc(&br->br_count); ++ wkq_err = au_wkq_nowait(reinit_br_wh, arg, sb, /*flags*/0); ++ if (unlikely(wkq_err)) { ++ atomic_dec(&br->br_wbr->wbr_wh_running); ++ au_lcnt_dec(&br->br_count); ++ au_kfree_rcu(arg); ++ } ++ do_dec = 0; ++ } ++ ++out: ++ if (do_dec) ++ atomic_dec(&br->br_wbr->wbr_wh_running); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * create the whiteout @wh. ++ */ ++static int link_or_create_wh(struct super_block *sb, aufs_bindex_t bindex, ++ struct dentry *wh) ++{ ++ int err; ++ struct path h_path = { ++ .dentry = wh ++ }; ++ struct au_branch *br; ++ struct au_wbr *wbr; ++ struct dentry *h_parent; ++ struct inode *h_dir, *delegated; ++ ++ h_parent = wh->d_parent; /* dir inode is locked */ ++ h_dir = d_inode(h_parent); ++ IMustLock(h_dir); ++ ++ br = au_sbr(sb, bindex); ++ h_path.mnt = au_br_mnt(br); ++ wbr = br->br_wbr; ++ wbr_wh_read_lock(wbr); ++ if (wbr->wbr_whbase) { ++ delegated = NULL; ++ err = vfsub_link(wbr->wbr_whbase, h_dir, &h_path, &delegated); ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal link\n"); ++ iput(delegated); ++ } ++ if (!err || err != -EMLINK) ++ goto out; ++ ++ /* link count full. re-initialize br_whbase. */ ++ kick_reinit_br_wh(sb, br); ++ } ++ ++ /* return this error in this context */ ++ err = vfsub_create(h_dir, &h_path, WH_MASK, /*want_excl*/true); ++ if (!err) ++ au_fhsm_wrote(sb, bindex, /*force*/0); ++ ++out: ++ wbr_wh_read_unlock(wbr); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * create or remove the diropq. ++ */ ++static struct dentry *do_diropq(struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int flags) ++{ ++ struct dentry *opq_dentry, *h_dentry; ++ struct super_block *sb; ++ struct au_branch *br; ++ int err; ++ ++ sb = dentry->d_sb; ++ br = au_sbr(sb, bindex); ++ h_dentry = au_h_dptr(dentry, bindex); ++ opq_dentry = vfsub_lkup_one(&diropq_name, h_dentry); ++ if (IS_ERR(opq_dentry)) ++ goto out; ++ ++ if (au_ftest_diropq(flags, CREATE)) { ++ err = link_or_create_wh(sb, bindex, opq_dentry); ++ if (!err) { ++ au_set_dbdiropq(dentry, bindex); ++ goto out; /* success */ ++ } ++ } else { ++ struct path tmp = { ++ .dentry = opq_dentry, ++ .mnt = au_br_mnt(br) ++ }; ++ err = do_unlink_wh(au_h_iptr(d_inode(dentry), bindex), &tmp); ++ if (!err) ++ au_set_dbdiropq(dentry, -1); ++ } ++ dput(opq_dentry); ++ opq_dentry = ERR_PTR(err); ++ ++out: ++ return opq_dentry; ++} ++ ++struct do_diropq_args { ++ struct dentry **errp; ++ struct dentry *dentry; ++ aufs_bindex_t bindex; ++ unsigned int flags; ++}; ++ ++static void call_do_diropq(void *args) ++{ ++ struct do_diropq_args *a = args; ++ *a->errp = do_diropq(a->dentry, a->bindex, a->flags); ++} ++ ++struct dentry *au_diropq_sio(struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int flags) ++{ ++ struct dentry *diropq, *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!au_test_h_perm_sio(d_inode(h_dentry), MAY_EXEC | MAY_WRITE)) ++ diropq = do_diropq(dentry, bindex, flags); ++ else { ++ int wkq_err; ++ struct do_diropq_args args = { ++ .errp = &diropq, ++ .dentry = dentry, ++ .bindex = bindex, ++ .flags = flags ++ }; ++ ++ wkq_err = au_wkq_wait(call_do_diropq, &args); ++ if (unlikely(wkq_err)) ++ diropq = ERR_PTR(wkq_err); ++ } ++ ++ return diropq; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * lookup whiteout dentry. ++ * @h_parent: lower parent dentry which must exist and be locked ++ * @base_name: name of dentry which will be whiteouted ++ * returns dentry for whiteout. ++ */ ++struct dentry *au_wh_lkup(struct dentry *h_parent, struct qstr *base_name, ++ struct au_branch *br) ++{ ++ int err; ++ struct qstr wh_name; ++ struct dentry *wh_dentry; ++ ++ err = au_wh_name_alloc(&wh_name, base_name); ++ wh_dentry = ERR_PTR(err); ++ if (!err) { ++ wh_dentry = vfsub_lkup_one(&wh_name, h_parent); ++ au_kfree_try_rcu(wh_name.name); ++ } ++ return wh_dentry; ++} ++ ++/* ++ * link/create a whiteout for @dentry on @bindex. ++ */ ++struct dentry *au_wh_create(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent) ++{ ++ struct dentry *wh_dentry; ++ struct super_block *sb; ++ int err; ++ ++ sb = dentry->d_sb; ++ wh_dentry = au_wh_lkup(h_parent, &dentry->d_name, au_sbr(sb, bindex)); ++ if (!IS_ERR(wh_dentry) && d_is_negative(wh_dentry)) { ++ err = link_or_create_wh(sb, bindex, wh_dentry); ++ if (!err) { ++ au_set_dbwh(dentry, bindex); ++ au_fhsm_wrote(sb, bindex, /*force*/0); ++ } else { ++ dput(wh_dentry); ++ wh_dentry = ERR_PTR(err); ++ } ++ } ++ ++ return wh_dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* Delete all whiteouts in this directory on branch bindex. */ ++static int del_wh_children(struct dentry *h_dentry, struct au_nhash *whlist, ++ aufs_bindex_t bindex, struct au_branch *br) ++{ ++ int err; ++ unsigned long ul, n; ++ struct qstr wh_name; ++ char *p; ++ struct hlist_head *head; ++ struct au_vdir_wh *pos; ++ struct au_vdir_destr *str; ++ ++ err = -ENOMEM; ++ p = (void *)__get_free_page(GFP_NOFS); ++ wh_name.name = p; ++ if (unlikely(!wh_name.name)) ++ goto out; ++ ++ err = 0; ++ memcpy(p, AUFS_WH_PFX, AUFS_WH_PFX_LEN); ++ p += AUFS_WH_PFX_LEN; ++ n = whlist->nh_num; ++ head = whlist->nh_head; ++ for (ul = 0; !err && ul < n; ul++, head++) { ++ hlist_for_each_entry(pos, head, wh_hash) { ++ if (pos->wh_bindex != bindex) ++ continue; ++ ++ str = &pos->wh_str; ++ if (str->len + AUFS_WH_PFX_LEN <= PATH_MAX) { ++ memcpy(p, str->name, str->len); ++ wh_name.len = AUFS_WH_PFX_LEN + str->len; ++ err = unlink_wh_name(h_dentry, &wh_name, br); ++ if (!err) ++ continue; ++ break; ++ } ++ AuIOErr("whiteout name too long %.*s\n", ++ str->len, str->name); ++ err = -EIO; ++ break; ++ } ++ } ++ free_page((unsigned long)wh_name.name); ++ ++out: ++ return err; ++} ++ ++struct del_wh_children_args { ++ int *errp; ++ struct dentry *h_dentry; ++ struct au_nhash *whlist; ++ aufs_bindex_t bindex; ++ struct au_branch *br; ++}; ++ ++static void call_del_wh_children(void *args) ++{ ++ struct del_wh_children_args *a = args; ++ *a->errp = del_wh_children(a->h_dentry, a->whlist, a->bindex, a->br); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_whtmp_rmdir *au_whtmp_rmdir_alloc(struct super_block *sb, gfp_t gfp) ++{ ++ struct au_whtmp_rmdir *whtmp; ++ int err; ++ unsigned int rdhash; ++ ++ SiMustAnyLock(sb); ++ ++ whtmp = kzalloc(sizeof(*whtmp), gfp); ++ if (unlikely(!whtmp)) { ++ whtmp = ERR_PTR(-ENOMEM); ++ goto out; ++ } ++ ++ /* no estimation for dir size */ ++ rdhash = au_sbi(sb)->si_rdhash; ++ if (!rdhash) ++ rdhash = AUFS_RDHASH_DEF; ++ err = au_nhash_alloc(&whtmp->whlist, rdhash, gfp); ++ if (unlikely(err)) { ++ au_kfree_rcu(whtmp); ++ whtmp = ERR_PTR(err); ++ } ++ ++out: ++ return whtmp; ++} ++ ++void au_whtmp_rmdir_free(struct au_whtmp_rmdir *whtmp) ++{ ++ if (whtmp->br) ++ au_lcnt_dec(&whtmp->br->br_count); ++ dput(whtmp->wh_dentry); ++ iput(whtmp->dir); ++ au_nhash_wh_free(&whtmp->whlist); ++ au_kfree_rcu(whtmp); ++} ++ ++/* ++ * rmdir the whiteouted temporary named dir @h_dentry. ++ * @whlist: whiteouted children. ++ */ ++int au_whtmp_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_nhash *whlist) ++{ ++ int err; ++ unsigned int h_nlink; ++ struct path h_tmp; ++ struct inode *wh_inode, *h_dir; ++ struct au_branch *br; ++ ++ h_dir = d_inode(wh_dentry->d_parent); /* dir inode is locked */ ++ IMustLock(h_dir); ++ ++ br = au_sbr(dir->i_sb, bindex); ++ wh_inode = d_inode(wh_dentry); ++ inode_lock_nested(wh_inode, AuLsc_I_CHILD); ++ ++ /* ++ * someone else might change some whiteouts while we were sleeping. ++ * it means this whlist may have an obsoleted entry. ++ */ ++ if (!au_test_h_perm_sio(wh_inode, MAY_EXEC | MAY_WRITE)) ++ err = del_wh_children(wh_dentry, whlist, bindex, br); ++ else { ++ int wkq_err; ++ struct del_wh_children_args args = { ++ .errp = &err, ++ .h_dentry = wh_dentry, ++ .whlist = whlist, ++ .bindex = bindex, ++ .br = br ++ }; ++ ++ wkq_err = au_wkq_wait(call_del_wh_children, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ inode_unlock(wh_inode); ++ ++ if (!err) { ++ h_tmp.dentry = wh_dentry; ++ h_tmp.mnt = au_br_mnt(br); ++ h_nlink = h_dir->i_nlink; ++ err = vfsub_rmdir(h_dir, &h_tmp); ++ /* some fs doesn't change the parent nlink in some cases */ ++ h_nlink -= h_dir->i_nlink; ++ } ++ ++ if (!err) { ++ if (au_ibtop(dir) == bindex) { ++ /* todo: dir->i_mutex is necessary */ ++ au_cpup_attr_timesizes(dir); ++ if (h_nlink) ++ vfsub_drop_nlink(dir); ++ } ++ return 0; /* success */ ++ } ++ ++ pr_warn("failed removing %pd(%d), ignored\n", wh_dentry, err); ++ return err; ++} ++ ++static void call_rmdir_whtmp(void *args) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct au_whtmp_rmdir *a = args; ++ struct super_block *sb; ++ struct dentry *h_parent; ++ struct inode *h_dir; ++ struct au_hinode *hdir; ++ ++ /* rmdir by nfsd may cause deadlock with this i_mutex */ ++ /* inode_lock(a->dir); */ ++ err = -EROFS; ++ sb = a->dir->i_sb; ++ si_read_lock(sb, !AuLock_FLUSH); ++ if (!au_br_writable(a->br->br_perm)) ++ goto out; ++ bindex = au_br_index(sb, a->br->br_id); ++ if (unlikely(bindex < 0)) ++ goto out; ++ ++ err = -EIO; ++ ii_write_lock_parent(a->dir); ++ h_parent = dget_parent(a->wh_dentry); ++ h_dir = d_inode(h_parent); ++ hdir = au_hi(a->dir, bindex); ++ err = vfsub_mnt_want_write(au_br_mnt(a->br)); ++ if (unlikely(err)) ++ goto out_mnt; ++ au_hn_inode_lock_nested(hdir, AuLsc_I_PARENT); ++ err = au_h_verify(a->wh_dentry, au_opt_udba(sb), h_dir, h_parent, ++ a->br); ++ if (!err) ++ err = au_whtmp_rmdir(a->dir, bindex, a->wh_dentry, &a->whlist); ++ au_hn_inode_unlock(hdir); ++ vfsub_mnt_drop_write(au_br_mnt(a->br)); ++ ++out_mnt: ++ dput(h_parent); ++ ii_write_unlock(a->dir); ++out: ++ /* inode_unlock(a->dir); */ ++ au_whtmp_rmdir_free(a); ++ si_read_unlock(sb); ++ au_nwt_done(&au_sbi(sb)->si_nowait); ++ if (unlikely(err)) ++ AuIOErr("err %d\n", err); ++} ++ ++void au_whtmp_kick_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_whtmp_rmdir *args) ++{ ++ int wkq_err; ++ struct super_block *sb; ++ ++ IMustLock(dir); ++ ++ /* all post-process will be done in do_rmdir_whtmp(). */ ++ sb = dir->i_sb; ++ args->dir = au_igrab(dir); ++ args->br = au_sbr(sb, bindex); ++ au_lcnt_inc(&args->br->br_count); ++ args->wh_dentry = dget(wh_dentry); ++ wkq_err = au_wkq_nowait(call_rmdir_whtmp, args, sb, /*flags*/0); ++ if (unlikely(wkq_err)) { ++ pr_warn("rmdir error %pd (%d), ignored\n", wh_dentry, wkq_err); ++ au_whtmp_rmdir_free(args); ++ } ++} +diff --git a/fs/aufs/whout.h b/fs/aufs/whout.h +new file mode 100644 +index 000000000000..dc4eb41e70dd +--- /dev/null ++++ b/fs/aufs/whout.h +@@ -0,0 +1,73 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * whiteout for logical deletion and opaque directory ++ */ ++ ++#ifndef __AUFS_WHOUT_H__ ++#define __AUFS_WHOUT_H__ ++ ++#ifdef __KERNEL__ ++ ++#include "dir.h" ++ ++/* whout.c */ ++int au_wh_name_alloc(struct qstr *wh, const struct qstr *name); ++int au_wh_test(struct dentry *h_parent, struct qstr *wh_name, int try_sio); ++int au_diropq_test(struct dentry *h_dentry); ++struct au_branch; ++struct dentry *au_whtmp_lkup(struct dentry *h_parent, struct au_branch *br, ++ struct qstr *prefix); ++int au_whtmp_ren(struct dentry *h_dentry, struct au_branch *br); ++int au_wh_unlink_dentry(struct inode *h_dir, struct path *h_path, ++ struct dentry *dentry); ++int au_wh_init(struct au_branch *br, struct super_block *sb); ++ ++/* diropq flags */ ++#define AuDiropq_CREATE 1 ++#define au_ftest_diropq(flags, name) ((flags) & AuDiropq_##name) ++#define au_fset_diropq(flags, name) \ ++ do { (flags) |= AuDiropq_##name; } while (0) ++#define au_fclr_diropq(flags, name) \ ++ do { (flags) &= ~AuDiropq_##name; } while (0) ++ ++struct dentry *au_diropq_sio(struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int flags); ++struct dentry *au_wh_lkup(struct dentry *h_parent, struct qstr *base_name, ++ struct au_branch *br); ++struct dentry *au_wh_create(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent); ++ ++/* real rmdir for the whiteout-ed dir */ ++struct au_whtmp_rmdir { ++ struct inode *dir; ++ struct au_branch *br; ++ struct dentry *wh_dentry; ++ struct au_nhash whlist; ++}; ++ ++struct au_whtmp_rmdir *au_whtmp_rmdir_alloc(struct super_block *sb, gfp_t gfp); ++void au_whtmp_rmdir_free(struct au_whtmp_rmdir *whtmp); ++int au_whtmp_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_nhash *whlist); ++void au_whtmp_kick_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_whtmp_rmdir *args); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct dentry *au_diropq_create(struct dentry *dentry, ++ aufs_bindex_t bindex) ++{ ++ return au_diropq_sio(dentry, bindex, AuDiropq_CREATE); ++} ++ ++static inline int au_diropq_remove(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ return PTR_ERR(au_diropq_sio(dentry, bindex, !AuDiropq_CREATE)); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_WHOUT_H__ */ +diff --git a/fs/aufs/wkq.c b/fs/aufs/wkq.c +new file mode 100644 +index 000000000000..288f5cf4b200 +--- /dev/null ++++ b/fs/aufs/wkq.c +@@ -0,0 +1,359 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * workqueue for asynchronous/super-io operations ++ * todo: try new credential scheme ++ */ ++ ++#include ++#include "aufs.h" ++ ++/* internal workqueue named AUFS_WKQ_NAME */ ++ ++static struct workqueue_struct *au_wkq; ++ ++struct au_wkinfo { ++ struct work_struct wk; ++ struct kobject *kobj; ++ ++ unsigned int flags; /* see wkq.h */ ++ ++ au_wkq_func_t func; ++ void *args; ++ ++#ifdef CONFIG_LOCKDEP ++ int dont_check; ++ struct held_lock **hlock; ++#endif ++ ++ struct completion *comp; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * Aufs passes some operations to the workqueue such as the internal copyup. ++ * This scheme looks rather unnatural for LOCKDEP debugging feature, since the ++ * job run by workqueue depends upon the locks acquired in the other task. ++ * Delegating a small operation to the workqueue, aufs passes its lockdep ++ * information too. And the job in the workqueue restores the info in order to ++ * pretend as if it acquired those locks. This is just to make LOCKDEP work ++ * correctly and expectedly. ++ */ ++ ++#ifndef CONFIG_LOCKDEP ++AuStubInt0(au_wkq_lockdep_alloc, struct au_wkinfo *wkinfo); ++AuStubVoid(au_wkq_lockdep_free, struct au_wkinfo *wkinfo); ++AuStubVoid(au_wkq_lockdep_pre, struct au_wkinfo *wkinfo); ++AuStubVoid(au_wkq_lockdep_post, struct au_wkinfo *wkinfo); ++AuStubVoid(au_wkq_lockdep_init, struct au_wkinfo *wkinfo); ++#else ++static void au_wkq_lockdep_init(struct au_wkinfo *wkinfo) ++{ ++ wkinfo->hlock = NULL; ++ wkinfo->dont_check = 0; ++} ++ ++/* ++ * 1: matched ++ * 0: unmatched ++ */ ++static int au_wkq_lockdep_test(struct lock_class_key *key, const char *name) ++{ ++ static DEFINE_SPINLOCK(spin); ++ static struct { ++ char *name; ++ struct lock_class_key *key; ++ } a[] = { ++ { .name = "&sbinfo->si_rwsem" }, ++ { .name = "&finfo->fi_rwsem" }, ++ { .name = "&dinfo->di_rwsem" }, ++ { .name = "&iinfo->ii_rwsem" } ++ }; ++ static int set; ++ int i; ++ ++ /* lockless read from 'set.' see below */ ++ if (set == ARRAY_SIZE(a)) { ++ for (i = 0; i < ARRAY_SIZE(a); i++) ++ if (a[i].key == key) ++ goto match; ++ goto unmatch; ++ } ++ ++ spin_lock(&spin); ++ if (set) ++ for (i = 0; i < ARRAY_SIZE(a); i++) ++ if (a[i].key == key) { ++ spin_unlock(&spin); ++ goto match; ++ } ++ for (i = 0; i < ARRAY_SIZE(a); i++) { ++ if (a[i].key) { ++ if (unlikely(a[i].key == key)) { /* rare but possible */ ++ spin_unlock(&spin); ++ goto match; ++ } else ++ continue; ++ } ++ if (strstr(a[i].name, name)) { ++ /* ++ * the order of these three lines is important for the ++ * lockless read above. ++ */ ++ a[i].key = key; ++ spin_unlock(&spin); ++ set++; ++ /* AuDbg("%d, %s\n", set, name); */ ++ goto match; ++ } ++ } ++ spin_unlock(&spin); ++ goto unmatch; ++ ++match: ++ return 1; ++unmatch: ++ return 0; ++} ++ ++static int au_wkq_lockdep_alloc(struct au_wkinfo *wkinfo) ++{ ++ int err, n; ++ struct task_struct *curr; ++ struct held_lock **hl, *held_locks, *p; ++ ++ err = 0; ++ curr = current; ++ wkinfo->dont_check = lockdep_recursing(curr); ++ if (wkinfo->dont_check) ++ goto out; ++ n = curr->lockdep_depth; ++ if (!n) ++ goto out; ++ ++ err = -ENOMEM; ++ wkinfo->hlock = kmalloc_array(n + 1, sizeof(*wkinfo->hlock), GFP_NOFS); ++ if (unlikely(!wkinfo->hlock)) ++ goto out; ++ ++ err = 0; ++#if 0 /* left for debugging */ ++ if (0 && au_debug_test()) ++ lockdep_print_held_locks(curr); ++#endif ++ held_locks = curr->held_locks; ++ hl = wkinfo->hlock; ++ while (n--) { ++ p = held_locks++; ++ if (au_wkq_lockdep_test(p->instance->key, p->instance->name)) ++ *hl++ = p; ++ } ++ *hl = NULL; ++ ++out: ++ return err; ++} ++ ++static void au_wkq_lockdep_free(struct au_wkinfo *wkinfo) ++{ ++ au_kfree_try_rcu(wkinfo->hlock); ++} ++ ++static void au_wkq_lockdep_pre(struct au_wkinfo *wkinfo) ++{ ++ struct held_lock *p, **hl = wkinfo->hlock; ++ int subclass; ++ ++ if (wkinfo->dont_check) ++ lockdep_off(); ++ if (!hl) ++ return; ++ while ((p = *hl++)) { /* assignment */ ++ subclass = lockdep_hlock_class(p)->subclass; ++ /* AuDbg("%s, %d\n", p->instance->name, subclass); */ ++ if (p->read) ++ rwsem_acquire_read(p->instance, subclass, 0, ++ /*p->acquire_ip*/_RET_IP_); ++ else ++ rwsem_acquire(p->instance, subclass, 0, ++ /*p->acquire_ip*/_RET_IP_); ++ } ++} ++ ++static void au_wkq_lockdep_post(struct au_wkinfo *wkinfo) ++{ ++ struct held_lock *p, **hl = wkinfo->hlock; ++ ++ if (wkinfo->dont_check) ++ lockdep_on(); ++ if (!hl) ++ return; ++ while ((p = *hl++)) /* assignment */ ++ rwsem_release(p->instance, /*p->acquire_ip*/_RET_IP_); ++} ++#endif ++ ++static void wkq_func(struct work_struct *wk) ++{ ++ struct au_wkinfo *wkinfo = container_of(wk, struct au_wkinfo, wk); ++ ++ AuDebugOn(!uid_eq(current_fsuid(), GLOBAL_ROOT_UID)); ++ AuDebugOn(rlimit(RLIMIT_FSIZE) != RLIM_INFINITY); ++ ++ au_wkq_lockdep_pre(wkinfo); ++ wkinfo->func(wkinfo->args); ++ au_wkq_lockdep_post(wkinfo); ++ if (au_ftest_wkq(wkinfo->flags, WAIT)) ++ complete(wkinfo->comp); ++ else { ++ kobject_put(wkinfo->kobj); ++ module_put(THIS_MODULE); /* todo: ?? */ ++ au_kfree_rcu(wkinfo); ++ } ++} ++ ++/* ++ * Since struct completion is large, try allocating it dynamically. ++ */ ++#define AuWkqCompDeclare(name) struct completion *comp = NULL ++ ++static int au_wkq_comp_alloc(struct au_wkinfo *wkinfo, struct completion **comp) ++{ ++ *comp = kmalloc(sizeof(**comp), GFP_NOFS); ++ if (*comp) { ++ init_completion(*comp); ++ wkinfo->comp = *comp; ++ return 0; ++ } ++ return -ENOMEM; ++} ++ ++static void au_wkq_comp_free(struct completion *comp) ++{ ++ au_kfree_rcu(comp); ++} ++ ++static void au_wkq_run(struct au_wkinfo *wkinfo) ++{ ++ if (au_ftest_wkq(wkinfo->flags, NEST)) { ++ if (au_wkq_test()) { ++ AuWarn1("wkq from wkq, unless silly-rename on NFS," ++ " due to a dead dir by UDBA," ++ " or async xino write?\n"); ++ AuDebugOn(au_ftest_wkq(wkinfo->flags, WAIT)); ++ } ++ } else ++ au_dbg_verify_kthread(); ++ ++ if (au_ftest_wkq(wkinfo->flags, WAIT)) { ++ INIT_WORK_ONSTACK(&wkinfo->wk, wkq_func); ++ queue_work(au_wkq, &wkinfo->wk); ++ } else { ++ INIT_WORK(&wkinfo->wk, wkq_func); ++ schedule_work(&wkinfo->wk); ++ } ++} ++ ++/* ++ * Be careful. It is easy to make deadlock happen. ++ * processA: lock, wkq and wait ++ * processB: wkq and wait, lock in wkq ++ * --> deadlock ++ */ ++int au_wkq_do_wait(unsigned int flags, au_wkq_func_t func, void *args) ++{ ++ int err; ++ AuWkqCompDeclare(comp); ++ struct au_wkinfo wkinfo = { ++ .flags = flags, ++ .func = func, ++ .args = args ++ }; ++ ++ err = au_wkq_comp_alloc(&wkinfo, &comp); ++ if (unlikely(err)) ++ goto out; ++ err = au_wkq_lockdep_alloc(&wkinfo); ++ if (unlikely(err)) ++ goto out_comp; ++ if (!err) { ++ au_wkq_run(&wkinfo); ++ /* no timeout, no interrupt */ ++ wait_for_completion(wkinfo.comp); ++ } ++ au_wkq_lockdep_free(&wkinfo); ++ ++out_comp: ++ au_wkq_comp_free(comp); ++out: ++ destroy_work_on_stack(&wkinfo.wk); ++ return err; ++} ++ ++/* ++ * Note: dget/dput() in func for aufs dentries are not supported. It will be a ++ * problem in a concurrent umounting. ++ */ ++int au_wkq_nowait(au_wkq_func_t func, void *args, struct super_block *sb, ++ unsigned int flags) ++{ ++ int err; ++ struct au_wkinfo *wkinfo; ++ ++ atomic_inc(&au_sbi(sb)->si_nowait.nw_len); ++ ++ /* ++ * wkq_func() must free this wkinfo. ++ * it highly depends upon the implementation of workqueue. ++ */ ++ err = 0; ++ wkinfo = kmalloc(sizeof(*wkinfo), GFP_NOFS); ++ if (wkinfo) { ++ wkinfo->kobj = &au_sbi(sb)->si_kobj; ++ wkinfo->flags = flags & ~AuWkq_WAIT; ++ wkinfo->func = func; ++ wkinfo->args = args; ++ wkinfo->comp = NULL; ++ au_wkq_lockdep_init(wkinfo); ++ kobject_get(wkinfo->kobj); ++ __module_get(THIS_MODULE); /* todo: ?? */ ++ ++ au_wkq_run(wkinfo); ++ } else { ++ err = -ENOMEM; ++ au_nwt_done(&au_sbi(sb)->si_nowait); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_nwt_init(struct au_nowait_tasks *nwt) ++{ ++ atomic_set(&nwt->nw_len, 0); ++ /* smp_mb(); */ /* atomic_set */ ++ init_waitqueue_head(&nwt->nw_wq); ++} ++ ++void au_wkq_fin(void) ++{ ++ destroy_workqueue(au_wkq); ++} ++ ++int __init au_wkq_init(void) ++{ ++ int err; ++ ++ err = 0; ++ au_wkq = alloc_workqueue(AUFS_WKQ_NAME, 0, WQ_DFL_ACTIVE); ++ if (IS_ERR(au_wkq)) ++ err = PTR_ERR(au_wkq); ++ else if (!au_wkq) ++ err = -ENOMEM; ++ ++ return err; ++} +diff --git a/fs/aufs/wkq.h b/fs/aufs/wkq.h +new file mode 100644 +index 000000000000..850085fdd2d2 +--- /dev/null ++++ b/fs/aufs/wkq.h +@@ -0,0 +1,76 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * workqueue for asynchronous/super-io operations ++ * todo: try new credentials management scheme ++ */ ++ ++#ifndef __AUFS_WKQ_H__ ++#define __AUFS_WKQ_H__ ++ ++#ifdef __KERNEL__ ++ ++#include ++ ++struct super_block; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * in the next operation, wait for the 'nowait' tasks in system-wide workqueue ++ */ ++struct au_nowait_tasks { ++ atomic_t nw_len; ++ wait_queue_head_t nw_wq; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++typedef void (*au_wkq_func_t)(void *args); ++ ++/* wkq flags */ ++#define AuWkq_WAIT 1 ++#define AuWkq_NEST (1 << 1) ++#define au_ftest_wkq(flags, name) ((flags) & AuWkq_##name) ++#define au_fset_wkq(flags, name) \ ++ do { (flags) |= AuWkq_##name; } while (0) ++#define au_fclr_wkq(flags, name) \ ++ do { (flags) &= ~AuWkq_##name; } while (0) ++ ++/* wkq.c */ ++int au_wkq_do_wait(unsigned int flags, au_wkq_func_t func, void *args); ++int au_wkq_nowait(au_wkq_func_t func, void *args, struct super_block *sb, ++ unsigned int flags); ++void au_nwt_init(struct au_nowait_tasks *nwt); ++int __init au_wkq_init(void); ++void au_wkq_fin(void); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline int au_wkq_test(void) ++{ ++ return current->flags & PF_WQ_WORKER; ++} ++ ++static inline int au_wkq_wait(au_wkq_func_t func, void *args) ++{ ++ return au_wkq_do_wait(AuWkq_WAIT, func, args); ++} ++ ++static inline void au_nwt_done(struct au_nowait_tasks *nwt) ++{ ++ if (atomic_dec_and_test(&nwt->nw_len)) ++ wake_up_all(&nwt->nw_wq); ++} ++ ++static inline int au_nwt_flush(struct au_nowait_tasks *nwt) ++{ ++ wait_event(nwt->nw_wq, !atomic_read(&nwt->nw_len)); ++ return 0; ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_WKQ_H__ */ +diff --git a/fs/aufs/xattr.c b/fs/aufs/xattr.c +new file mode 100644 +index 000000000000..a71145b741b1 +--- /dev/null ++++ b/fs/aufs/xattr.c +@@ -0,0 +1,343 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2014-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * handling xattr functions ++ */ ++ ++#include ++#include ++#include ++#include "aufs.h" ++ ++static int au_xattr_ignore(int err, char *name, unsigned int ignore_flags) ++{ ++ if (!ignore_flags) ++ goto out; ++ switch (err) { ++ case -ENOMEM: ++ case -EDQUOT: ++ goto out; ++ } ++ ++ if ((ignore_flags & AuBrAttr_ICEX) == AuBrAttr_ICEX) { ++ err = 0; ++ goto out; ++ } ++ ++#define cmp(brattr, prefix) do { \ ++ if (!strncmp(name, XATTR_##prefix##_PREFIX, \ ++ XATTR_##prefix##_PREFIX_LEN)) { \ ++ if (ignore_flags & AuBrAttr_ICEX_##brattr) \ ++ err = 0; \ ++ goto out; \ ++ } \ ++ } while (0) ++ ++ cmp(SEC, SECURITY); ++ cmp(SYS, SYSTEM); ++ cmp(TR, TRUSTED); ++ cmp(USR, USER); ++#undef cmp ++ ++ if (ignore_flags & AuBrAttr_ICEX_OTH) ++ err = 0; ++ ++out: ++ return err; ++} ++ ++static const int au_xattr_out_of_list = AuBrAttr_ICEX_OTH << 1; ++ ++static int au_do_cpup_xattr(struct dentry *h_dst, struct dentry *h_src, ++ char *name, char **buf, unsigned int ignore_flags, ++ unsigned int verbose) ++{ ++ int err; ++ ssize_t ssz; ++ struct inode *h_idst; ++ ++ ssz = vfs_getxattr_alloc(h_src, name, buf, 0, GFP_NOFS); ++ err = ssz; ++ if (unlikely(err <= 0)) { ++ if (err == -ENODATA ++ || (err == -EOPNOTSUPP ++ && ((ignore_flags & au_xattr_out_of_list) ++ || (au_test_nfs_noacl(d_inode(h_src)) ++ && (!strcmp(name, XATTR_NAME_POSIX_ACL_ACCESS) ++ || !strcmp(name, ++ XATTR_NAME_POSIX_ACL_DEFAULT)))) ++ )) ++ err = 0; ++ if (err && (verbose || au_debug_test())) ++ pr_err("%s, err %d\n", name, err); ++ goto out; ++ } ++ ++ /* unlock it temporary */ ++ h_idst = d_inode(h_dst); ++ inode_unlock(h_idst); ++ err = vfsub_setxattr(h_dst, name, *buf, ssz, /*flags*/0); ++ inode_lock_nested(h_idst, AuLsc_I_CHILD2); ++ if (unlikely(err)) { ++ if (verbose || au_debug_test()) ++ pr_err("%s, err %d\n", name, err); ++ err = au_xattr_ignore(err, name, ignore_flags); ++ } ++ ++out: ++ return err; ++} ++ ++int au_cpup_xattr(struct dentry *h_dst, struct dentry *h_src, int ignore_flags, ++ unsigned int verbose) ++{ ++ int err, unlocked, acl_access, acl_default; ++ ssize_t ssz; ++ struct inode *h_isrc, *h_idst; ++ char *value, *p, *o, *e; ++ ++ /* try stopping to update the source inode while we are referencing */ ++ /* there should not be the parent-child relationship between them */ ++ h_isrc = d_inode(h_src); ++ h_idst = d_inode(h_dst); ++ inode_unlock(h_idst); ++ inode_lock_shared_nested(h_isrc, AuLsc_I_CHILD); ++ inode_lock_nested(h_idst, AuLsc_I_CHILD2); ++ unlocked = 0; ++ ++ /* some filesystems don't list POSIX ACL, for example tmpfs */ ++ ssz = vfs_listxattr(h_src, NULL, 0); ++ err = ssz; ++ if (unlikely(err < 0)) { ++ AuTraceErr(err); ++ if (err == -ENODATA ++ || err == -EOPNOTSUPP) ++ err = 0; /* ignore */ ++ goto out; ++ } ++ ++ err = 0; ++ p = NULL; ++ o = NULL; ++ if (ssz) { ++ err = -ENOMEM; ++ p = kmalloc(ssz, GFP_NOFS); ++ o = p; ++ if (unlikely(!p)) ++ goto out; ++ err = vfs_listxattr(h_src, p, ssz); ++ } ++ inode_unlock_shared(h_isrc); ++ unlocked = 1; ++ AuDbg("err %d, ssz %zd\n", err, ssz); ++ if (unlikely(err < 0)) ++ goto out_free; ++ ++ err = 0; ++ e = p + ssz; ++ value = NULL; ++ acl_access = 0; ++ acl_default = 0; ++ while (!err && p < e) { ++ acl_access |= !strncmp(p, XATTR_NAME_POSIX_ACL_ACCESS, ++ sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1); ++ acl_default |= !strncmp(p, XATTR_NAME_POSIX_ACL_DEFAULT, ++ sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) ++ - 1); ++ err = au_do_cpup_xattr(h_dst, h_src, p, &value, ignore_flags, ++ verbose); ++ p += strlen(p) + 1; ++ } ++ AuTraceErr(err); ++ ignore_flags |= au_xattr_out_of_list; ++ if (!err && !acl_access) { ++ err = au_do_cpup_xattr(h_dst, h_src, ++ XATTR_NAME_POSIX_ACL_ACCESS, &value, ++ ignore_flags, verbose); ++ AuTraceErr(err); ++ } ++ if (!err && !acl_default) { ++ err = au_do_cpup_xattr(h_dst, h_src, ++ XATTR_NAME_POSIX_ACL_DEFAULT, &value, ++ ignore_flags, verbose); ++ AuTraceErr(err); ++ } ++ ++ au_kfree_try_rcu(value); ++ ++out_free: ++ au_kfree_try_rcu(o); ++out: ++ if (!unlocked) ++ inode_unlock_shared(h_isrc); ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_smack_reentering(struct super_block *sb) ++{ ++#if IS_ENABLED(CONFIG_SECURITY_SMACK) || IS_ENABLED(CONFIG_SECURITY_SELINUX) ++ /* ++ * as a part of lookup, smack_d_instantiate() is called, and it calls ++ * i_op->getxattr(). ouch. ++ */ ++ return si_pid_test(sb); ++#else ++ return 0; ++#endif ++} ++ ++enum { ++ AU_XATTR_LIST, ++ AU_XATTR_GET ++}; ++ ++struct au_lgxattr { ++ int type; ++ union { ++ struct { ++ char *list; ++ size_t size; ++ } list; ++ struct { ++ const char *name; ++ void *value; ++ size_t size; ++ } get; ++ } u; ++}; ++ ++static ssize_t au_lgxattr(struct dentry *dentry, struct inode *inode, ++ struct au_lgxattr *arg) ++{ ++ ssize_t err; ++ int reenter; ++ struct path h_path; ++ struct super_block *sb; ++ ++ sb = dentry->d_sb; ++ reenter = au_smack_reentering(sb); ++ if (!reenter) { ++ err = si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLM); ++ if (unlikely(err)) ++ goto out; ++ } ++ err = au_h_path_getattr(dentry, inode, /*force*/1, &h_path, reenter); ++ if (unlikely(err)) ++ goto out_si; ++ if (unlikely(!h_path.dentry)) ++ /* illegally overlapped or something */ ++ goto out_di; /* pretending success */ ++ ++ /* always topmost entry only */ ++ switch (arg->type) { ++ case AU_XATTR_LIST: ++ err = vfs_listxattr(h_path.dentry, ++ arg->u.list.list, arg->u.list.size); ++ break; ++ case AU_XATTR_GET: ++ AuDebugOn(d_is_negative(h_path.dentry)); ++ err = vfs_getxattr(h_path.dentry, ++ arg->u.get.name, arg->u.get.value, ++ arg->u.get.size); ++ break; ++ } ++ ++out_di: ++ if (!reenter) ++ di_read_unlock(dentry, AuLock_IR); ++out_si: ++ if (!reenter) ++ si_read_unlock(sb); ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++ssize_t aufs_listxattr(struct dentry *dentry, char *list, size_t size) ++{ ++ struct au_lgxattr arg = { ++ .type = AU_XATTR_LIST, ++ .u.list = { ++ .list = list, ++ .size = size ++ }, ++ }; ++ ++ return au_lgxattr(dentry, /*inode*/NULL, &arg); ++} ++ ++static ssize_t au_getxattr(struct dentry *dentry, struct inode *inode, ++ const char *name, void *value, size_t size) ++{ ++ struct au_lgxattr arg = { ++ .type = AU_XATTR_GET, ++ .u.get = { ++ .name = name, ++ .value = value, ++ .size = size ++ }, ++ }; ++ ++ return au_lgxattr(dentry, inode, &arg); ++} ++ ++static int au_setxattr(struct dentry *dentry, struct inode *inode, ++ const char *name, const void *value, size_t size, ++ int flags) ++{ ++ struct au_sxattr arg = { ++ .type = AU_XATTR_SET, ++ .u.set = { ++ .name = name, ++ .value = value, ++ .size = size, ++ .flags = flags ++ }, ++ }; ++ ++ return au_sxattr(dentry, inode, &arg); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_xattr_get(const struct xattr_handler *handler, ++ struct dentry *dentry, struct inode *inode, ++ const char *name, void *buffer, size_t size) ++{ ++ return au_getxattr(dentry, inode, name, buffer, size); ++} ++ ++static int au_xattr_set(const struct xattr_handler *handler, ++ struct dentry *dentry, struct inode *inode, ++ const char *name, const void *value, size_t size, ++ int flags) ++{ ++ return au_setxattr(dentry, inode, name, value, size, flags); ++} ++ ++static const struct xattr_handler au_xattr_handler = { ++ .name = "", ++ .prefix = "", ++ .get = au_xattr_get, ++ .set = au_xattr_set ++}; ++ ++static const struct xattr_handler *au_xattr_handlers[] = { ++#ifdef CONFIG_FS_POSIX_ACL ++ &posix_acl_access_xattr_handler, ++ &posix_acl_default_xattr_handler, ++#endif ++ &au_xattr_handler, /* must be last */ ++ NULL ++}; ++ ++void au_xattr_init(struct super_block *sb) ++{ ++ sb->s_xattr = au_xattr_handlers; ++} +diff --git a/fs/aufs/xino.c b/fs/aufs/xino.c +new file mode 100644 +index 000000000000..ad2895dd6055 +--- /dev/null ++++ b/fs/aufs/xino.c +@@ -0,0 +1,1953 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++/* ++ * external inode number translation table and bitmap ++ * ++ * things to consider ++ * - the lifetime ++ * + au_xino object ++ * + XINO files (xino, xib, xigen) ++ * + dynamic debugfs entries (xiN) ++ * + static debugfs entries (xib, xigen) ++ * + static sysfs entry (xi_path) ++ * - several entry points to handle them. ++ * + mount(2) without xino option (default) ++ * + mount(2) with xino option ++ * + mount(2) with noxino option ++ * + umount(2) ++ * + remount with add/del branches ++ * + remount with xino/noxino options ++ */ ++ ++#include ++#include ++#include "aufs.h" ++ ++static aufs_bindex_t sbr_find_shared(struct super_block *sb, aufs_bindex_t btop, ++ aufs_bindex_t bbot, ++ struct super_block *h_sb) ++{ ++ /* todo: try binary-search if the branches are many */ ++ for (; btop <= bbot; btop++) ++ if (h_sb == au_sbr_sb(sb, btop)) ++ return btop; ++ return -1; ++} ++ ++/* ++ * find another branch who is on the same filesystem of the specified ++ * branch{@btgt}. search until @bbot. ++ */ ++static aufs_bindex_t is_sb_shared(struct super_block *sb, aufs_bindex_t btgt, ++ aufs_bindex_t bbot) ++{ ++ aufs_bindex_t bindex; ++ struct super_block *tgt_sb; ++ ++ tgt_sb = au_sbr_sb(sb, btgt); ++ bindex = sbr_find_shared(sb, /*btop*/0, btgt - 1, tgt_sb); ++ if (bindex < 0) ++ bindex = sbr_find_shared(sb, btgt + 1, bbot, tgt_sb); ++ ++ return bindex; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * stop unnecessary notify events at creating xino files ++ */ ++ ++aufs_bindex_t au_xi_root(struct super_block *sb, struct dentry *dentry) ++{ ++ aufs_bindex_t bfound, bindex, bbot; ++ struct dentry *parent; ++ struct au_branch *br; ++ ++ bfound = -1; ++ parent = dentry->d_parent; /* safe d_parent access */ ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_dentry(br) == parent) { ++ bfound = bindex; ++ break; ++ } ++ } ++ ++ AuDbg("bfound b%d\n", bfound); ++ return bfound; ++} ++ ++struct au_xino_lock_dir { ++ struct au_hinode *hdir; ++ struct dentry *parent; ++ struct inode *dir; ++}; ++ ++static struct dentry *au_dget_parent_lock(struct dentry *dentry, ++ unsigned int lsc) ++{ ++ struct dentry *parent; ++ struct inode *dir; ++ ++ parent = dget_parent(dentry); ++ dir = d_inode(parent); ++ inode_lock_nested(dir, lsc); ++#if 0 /* it should not happen */ ++ spin_lock(&dentry->d_lock); ++ if (unlikely(dentry->d_parent != parent)) { ++ spin_unlock(&dentry->d_lock); ++ inode_unlock(dir); ++ dput(parent); ++ parent = NULL; ++ goto out; ++ } ++ spin_unlock(&dentry->d_lock); ++ ++out: ++#endif ++ return parent; ++} ++ ++static void au_xino_lock_dir(struct super_block *sb, struct path *xipath, ++ struct au_xino_lock_dir *ldir) ++{ ++ aufs_bindex_t bindex; ++ ++ ldir->hdir = NULL; ++ bindex = au_xi_root(sb, xipath->dentry); ++ if (bindex >= 0) { ++ /* rw branch root */ ++ ldir->hdir = au_hi(d_inode(sb->s_root), bindex); ++ au_hn_inode_lock_nested(ldir->hdir, AuLsc_I_PARENT); ++ } else { ++ /* other */ ++ ldir->parent = au_dget_parent_lock(xipath->dentry, ++ AuLsc_I_PARENT); ++ ldir->dir = d_inode(ldir->parent); ++ } ++} ++ ++static void au_xino_unlock_dir(struct au_xino_lock_dir *ldir) ++{ ++ if (ldir->hdir) ++ au_hn_inode_unlock(ldir->hdir); ++ else { ++ inode_unlock(ldir->dir); ++ dput(ldir->parent); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * create and set a new xino file ++ */ ++struct file *au_xino_create(struct super_block *sb, char *fpath, int silent, ++ int wbrtop) ++{ ++ struct file *file; ++ struct dentry *h_parent, *d; ++ struct inode *h_dir, *inode; ++ int err; ++ static DEFINE_MUTEX(mtx); ++ ++ /* ++ * at mount-time, and the xino file is the default path, ++ * hnotify is disabled so we have no notify events to ignore. ++ * when a user specified the xino, we cannot get au_hdir to be ignored. ++ */ ++ if (!wbrtop) ++ mutex_lock(&mtx); ++ file = vfsub_filp_open(fpath, O_RDWR | O_CREAT | O_EXCL | O_LARGEFILE ++ /* | __FMODE_NONOTIFY */, ++ 0666); ++ if (IS_ERR(file)) { ++ if (!wbrtop) ++ mutex_unlock(&mtx); ++ if (!silent) ++ pr_err("open %s(%ld)\n", fpath, PTR_ERR(file)); ++ return file; ++ } ++ ++ /* keep file count */ ++ err = 0; ++ d = file->f_path.dentry; ++ h_parent = au_dget_parent_lock(d, AuLsc_I_PARENT); ++ if (!wbrtop) ++ mutex_unlock(&mtx); ++ /* mnt_want_write() is unnecessary here */ ++ h_dir = d_inode(h_parent); ++ inode = file_inode(file); ++ /* no delegation since it is just created */ ++ if (inode->i_nlink) ++ err = vfsub_unlink(h_dir, &file->f_path, /*delegated*/NULL, ++ /*force*/0); ++ inode_unlock(h_dir); ++ dput(h_parent); ++ if (unlikely(err)) { ++ if (!silent) ++ pr_err("unlink %s(%d)\n", fpath, err); ++ goto out; ++ } ++ ++ err = -EINVAL; ++ if (unlikely(sb == d->d_sb)) { ++ if (!silent) ++ pr_err("%s must be outside\n", fpath); ++ goto out; ++ } ++ if (unlikely(au_test_fs_bad_xino(d->d_sb))) { ++ if (!silent) ++ pr_err("xino doesn't support %s(%s)\n", ++ fpath, au_sbtype(d->d_sb)); ++ goto out; ++ } ++ return file; /* success */ ++ ++out: ++ fput(file); ++ file = ERR_PTR(err); ++ return file; ++} ++ ++/* ++ * create a new xinofile at the same place/path as @base. ++ */ ++struct file *au_xino_create2(struct super_block *sb, struct path *base, ++ struct file *copy_src) ++{ ++ struct file *file; ++ struct dentry *dentry, *parent; ++ struct inode *dir, *delegated; ++ struct qstr *name; ++ struct path path; ++ int err, do_unlock; ++ struct au_xino_lock_dir ldir; ++ ++ do_unlock = 1; ++ au_xino_lock_dir(sb, base, &ldir); ++ dentry = base->dentry; ++ parent = dentry->d_parent; /* dir inode is locked */ ++ dir = d_inode(parent); ++ IMustLock(dir); ++ ++ name = &dentry->d_name; ++ path.dentry = vfsub_lookup_one_len(name->name, parent, name->len); ++ if (IS_ERR(path.dentry)) { ++ file = (void *)path.dentry; ++ pr_err("%pd lookup err %ld\n", dentry, PTR_ERR(path.dentry)); ++ goto out; ++ } ++ ++ /* no need to mnt_want_write() since we call dentry_open() later */ ++ err = vfs_create(dir, path.dentry, 0666, NULL); ++ if (unlikely(err)) { ++ file = ERR_PTR(err); ++ pr_err("%pd create err %d\n", dentry, err); ++ goto out_dput; ++ } ++ ++ path.mnt = base->mnt; ++ file = vfsub_dentry_open(&path, ++ O_RDWR | O_CREAT | O_EXCL | O_LARGEFILE ++ /* | __FMODE_NONOTIFY */); ++ if (IS_ERR(file)) { ++ pr_err("%pd open err %ld\n", dentry, PTR_ERR(file)); ++ goto out_dput; ++ } ++ ++ delegated = NULL; ++ err = vfsub_unlink(dir, &file->f_path, &delegated, /*force*/0); ++ au_xino_unlock_dir(&ldir); ++ do_unlock = 0; ++ if (unlikely(err == -EWOULDBLOCK)) { ++ pr_warn("cannot retry for NFSv4 delegation" ++ " for an internal unlink\n"); ++ iput(delegated); ++ } ++ if (unlikely(err)) { ++ pr_err("%pd unlink err %d\n", dentry, err); ++ goto out_fput; ++ } ++ ++ if (copy_src) { ++ /* no one can touch copy_src xino */ ++ err = au_copy_file(file, copy_src, vfsub_f_size_read(copy_src)); ++ if (unlikely(err)) { ++ pr_err("%pd copy err %d\n", dentry, err); ++ goto out_fput; ++ } ++ } ++ goto out_dput; /* success */ ++ ++out_fput: ++ fput(file); ++ file = ERR_PTR(err); ++out_dput: ++ dput(path.dentry); ++out: ++ if (do_unlock) ++ au_xino_unlock_dir(&ldir); ++ return file; ++} ++ ++struct file *au_xino_file1(struct au_xino *xi) ++{ ++ struct file *file; ++ unsigned int u, nfile; ++ ++ file = NULL; ++ nfile = xi->xi_nfile; ++ for (u = 0; u < nfile; u++) { ++ file = xi->xi_file[u]; ++ if (file) ++ break; ++ } ++ ++ return file; ++} ++ ++static int au_xino_file_set(struct au_xino *xi, int idx, struct file *file) ++{ ++ int err; ++ struct file *f; ++ void *p; ++ ++ if (file) ++ get_file(file); ++ ++ err = 0; ++ f = NULL; ++ if (idx < xi->xi_nfile) { ++ f = xi->xi_file[idx]; ++ if (f) ++ fput(f); ++ } else { ++ p = au_kzrealloc(xi->xi_file, ++ sizeof(*xi->xi_file) * xi->xi_nfile, ++ sizeof(*xi->xi_file) * (idx + 1), ++ GFP_NOFS, /*may_shrink*/0); ++ if (p) { ++ MtxMustLock(&xi->xi_mtx); ++ xi->xi_file = p; ++ xi->xi_nfile = idx + 1; ++ } else { ++ err = -ENOMEM; ++ if (file) ++ fput(file); ++ goto out; ++ } ++ } ++ xi->xi_file[idx] = file; ++ ++out: ++ return err; ++} ++ ++/* ++ * if @xinew->xi is not set, then create new xigen file. ++ */ ++struct file *au_xi_new(struct super_block *sb, struct au_xi_new *xinew) ++{ ++ struct file *file; ++ int err; ++ ++ SiMustAnyLock(sb); ++ ++ file = au_xino_create2(sb, xinew->base, xinew->copy_src); ++ if (IS_ERR(file)) { ++ err = PTR_ERR(file); ++ pr_err("%s[%d], err %d\n", ++ xinew->xi ? "xino" : "xigen", ++ xinew->idx, err); ++ goto out; ++ } ++ ++ if (xinew->xi) ++ err = au_xino_file_set(xinew->xi, xinew->idx, file); ++ else { ++ BUG(); ++ /* todo: make xigen file an array */ ++ /* err = au_xigen_file_set(sb, xinew->idx, file); */ ++ } ++ fput(file); ++ if (unlikely(err)) ++ file = ERR_PTR(err); ++ ++out: ++ return file; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * truncate xino files ++ */ ++static int au_xino_do_trunc(struct super_block *sb, aufs_bindex_t bindex, ++ int idx, struct kstatfs *st) ++{ ++ int err; ++ blkcnt_t blocks; ++ struct file *file, *new_xino; ++ struct au_xi_new xinew = { ++ .idx = idx ++ }; ++ ++ err = 0; ++ xinew.xi = au_sbr(sb, bindex)->br_xino; ++ file = au_xino_file(xinew.xi, idx); ++ if (!file) ++ goto out; ++ ++ xinew.base = &file->f_path; ++ err = vfs_statfs(xinew.base, st); ++ if (unlikely(err)) { ++ AuErr1("statfs err %d, ignored\n", err); ++ err = 0; ++ goto out; ++ } ++ ++ blocks = file_inode(file)->i_blocks; ++ pr_info("begin truncating xino(b%d-%d), ib%llu, %llu/%llu free blks\n", ++ bindex, idx, (u64)blocks, st->f_bfree, st->f_blocks); ++ ++ xinew.copy_src = file; ++ new_xino = au_xi_new(sb, &xinew); ++ if (IS_ERR(new_xino)) { ++ err = PTR_ERR(new_xino); ++ pr_err("xino(b%d-%d), err %d, ignored\n", bindex, idx, err); ++ goto out; ++ } ++ ++ err = vfs_statfs(&new_xino->f_path, st); ++ if (!err) ++ pr_info("end truncating xino(b%d-%d), ib%llu, %llu/%llu free blks\n", ++ bindex, idx, (u64)file_inode(new_xino)->i_blocks, ++ st->f_bfree, st->f_blocks); ++ else { ++ AuErr1("statfs err %d, ignored\n", err); ++ err = 0; ++ } ++ ++out: ++ return err; ++} ++ ++int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex, int idx_begin) ++{ ++ int err, i; ++ unsigned long jiffy; ++ aufs_bindex_t bbot; ++ struct kstatfs *st; ++ struct au_branch *br; ++ struct au_xino *xi; ++ ++ err = -ENOMEM; ++ st = kmalloc(sizeof(*st), GFP_NOFS); ++ if (unlikely(!st)) ++ goto out; ++ ++ err = -EINVAL; ++ bbot = au_sbbot(sb); ++ if (unlikely(bindex < 0 || bbot < bindex)) ++ goto out_st; ++ ++ err = 0; ++ jiffy = jiffies; ++ br = au_sbr(sb, bindex); ++ xi = br->br_xino; ++ for (i = idx_begin; !err && i < xi->xi_nfile; i++) ++ err = au_xino_do_trunc(sb, bindex, i, st); ++ if (!err) ++ au_sbi(sb)->si_xino_jiffy = jiffy; ++ ++out_st: ++ au_kfree_rcu(st); ++out: ++ return err; ++} ++ ++struct xino_do_trunc_args { ++ struct super_block *sb; ++ struct au_branch *br; ++ int idx; ++}; ++ ++static void xino_do_trunc(void *_args) ++{ ++ struct xino_do_trunc_args *args = _args; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct inode *dir; ++ int err, idx; ++ aufs_bindex_t bindex; ++ ++ err = 0; ++ sb = args->sb; ++ dir = d_inode(sb->s_root); ++ br = args->br; ++ idx = args->idx; ++ ++ si_noflush_write_lock(sb); ++ ii_read_lock_parent(dir); ++ bindex = au_br_index(sb, br->br_id); ++ err = au_xino_trunc(sb, bindex, idx); ++ ii_read_unlock(dir); ++ if (unlikely(err)) ++ pr_warn("err b%d, (%d)\n", bindex, err); ++ atomic_dec(&br->br_xino->xi_truncating); ++ au_lcnt_dec(&br->br_count); ++ si_write_unlock(sb); ++ au_nwt_done(&au_sbi(sb)->si_nowait); ++ au_kfree_rcu(args); ++} ++ ++/* ++ * returns the index in the xi_file array whose corresponding file is necessary ++ * to truncate, or -1 which means no need to truncate. ++ */ ++static int xino_trunc_test(struct super_block *sb, struct au_branch *br) ++{ ++ int err; ++ unsigned int u; ++ struct kstatfs st; ++ struct au_sbinfo *sbinfo; ++ struct au_xino *xi; ++ struct file *file; ++ ++ /* todo: si_xino_expire and the ratio should be customizable */ ++ sbinfo = au_sbi(sb); ++ if (time_before(jiffies, ++ sbinfo->si_xino_jiffy + sbinfo->si_xino_expire)) ++ return -1; ++ ++ /* truncation border */ ++ xi = br->br_xino; ++ for (u = 0; u < xi->xi_nfile; u++) { ++ file = au_xino_file(xi, u); ++ if (!file) ++ continue; ++ ++ err = vfs_statfs(&file->f_path, &st); ++ if (unlikely(err)) { ++ AuErr1("statfs err %d, ignored\n", err); ++ return -1; ++ } ++ if (div64_u64(st.f_bfree * 100, st.f_blocks) ++ >= AUFS_XINO_DEF_TRUNC) ++ return u; ++ } ++ ++ return -1; ++} ++ ++static void xino_try_trunc(struct super_block *sb, struct au_branch *br) ++{ ++ int idx; ++ struct xino_do_trunc_args *args; ++ int wkq_err; ++ ++ idx = xino_trunc_test(sb, br); ++ if (idx < 0) ++ return; ++ ++ if (atomic_inc_return(&br->br_xino->xi_truncating) > 1) ++ goto out; ++ ++ /* lock and kfree() will be called in trunc_xino() */ ++ args = kmalloc(sizeof(*args), GFP_NOFS); ++ if (unlikely(!args)) { ++ AuErr1("no memory\n"); ++ goto out; ++ } ++ ++ au_lcnt_inc(&br->br_count); ++ args->sb = sb; ++ args->br = br; ++ args->idx = idx; ++ wkq_err = au_wkq_nowait(xino_do_trunc, args, sb, /*flags*/0); ++ if (!wkq_err) ++ return; /* success */ ++ ++ pr_err("wkq %d\n", wkq_err); ++ au_lcnt_dec(&br->br_count); ++ au_kfree_rcu(args); ++ ++out: ++ atomic_dec(&br->br_xino->xi_truncating); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_xi_calc { ++ int idx; ++ loff_t pos; ++}; ++ ++static void au_xi_calc(struct super_block *sb, ino_t h_ino, ++ struct au_xi_calc *calc) ++{ ++ loff_t maxent; ++ ++ maxent = au_xi_maxent(sb); ++ calc->idx = div64_u64_rem(h_ino, maxent, &calc->pos); ++ calc->pos *= sizeof(ino_t); ++} ++ ++static int au_xino_do_new_async(struct super_block *sb, struct au_branch *br, ++ struct au_xi_calc *calc) ++{ ++ int err; ++ struct file *file; ++ struct au_xino *xi = br->br_xino; ++ struct au_xi_new xinew = { ++ .xi = xi ++ }; ++ ++ SiMustAnyLock(sb); ++ ++ err = 0; ++ if (!xi) ++ goto out; ++ ++ mutex_lock(&xi->xi_mtx); ++ file = au_xino_file(xi, calc->idx); ++ if (file) ++ goto out_mtx; ++ ++ file = au_xino_file(xi, /*idx*/-1); ++ AuDebugOn(!file); ++ xinew.idx = calc->idx; ++ xinew.base = &file->f_path; ++ /* xinew.copy_src = NULL; */ ++ file = au_xi_new(sb, &xinew); ++ if (IS_ERR(file)) ++ err = PTR_ERR(file); ++ ++out_mtx: ++ mutex_unlock(&xi->xi_mtx); ++out: ++ return err; ++} ++ ++struct au_xino_do_new_async_args { ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_xi_calc calc; ++ ino_t ino; ++}; ++ ++struct au_xi_writing { ++ struct hlist_bl_node node; ++ ino_t h_ino, ino; ++}; ++ ++static int au_xino_do_write(vfs_writef_t write, struct file *file, ++ struct au_xi_calc *calc, ino_t ino); ++ ++static void au_xino_call_do_new_async(void *args) ++{ ++ struct au_xino_do_new_async_args *a = args; ++ struct au_branch *br; ++ struct super_block *sb; ++ struct au_sbinfo *sbi; ++ struct inode *root; ++ struct file *file; ++ struct au_xi_writing *del, *p; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ int err; ++ ++ br = a->br; ++ sb = a->sb; ++ sbi = au_sbi(sb); ++ si_noflush_read_lock(sb); ++ root = d_inode(sb->s_root); ++ ii_read_lock_child(root); ++ err = au_xino_do_new_async(sb, br, &a->calc); ++ if (unlikely(err)) { ++ AuIOErr("err %d\n", err); ++ goto out; ++ } ++ ++ file = au_xino_file(br->br_xino, a->calc.idx); ++ AuDebugOn(!file); ++ err = au_xino_do_write(sbi->si_xwrite, file, &a->calc, a->ino); ++ if (unlikely(err)) { ++ AuIOErr("err %d\n", err); ++ goto out; ++ } ++ ++ del = NULL; ++ hbl = &br->br_xino->xi_writing; ++ hlist_bl_lock(hbl); ++ au_hbl_for_each(pos, hbl) { ++ p = container_of(pos, struct au_xi_writing, node); ++ if (p->ino == a->ino) { ++ del = p; ++ hlist_bl_del(&p->node); ++ break; ++ } ++ } ++ hlist_bl_unlock(hbl); ++ au_kfree_rcu(del); ++ ++out: ++ au_lcnt_dec(&br->br_count); ++ ii_read_unlock(root); ++ si_read_unlock(sb); ++ au_nwt_done(&sbi->si_nowait); ++ au_kfree_rcu(a); ++} ++ ++/* ++ * create a new xino file asynchronously ++ */ ++static int au_xino_new_async(struct super_block *sb, struct au_branch *br, ++ struct au_xi_calc *calc, ino_t ino) ++{ ++ int err; ++ struct au_xino_do_new_async_args *arg; ++ ++ err = -ENOMEM; ++ arg = kmalloc(sizeof(*arg), GFP_NOFS); ++ if (unlikely(!arg)) ++ goto out; ++ ++ arg->sb = sb; ++ arg->br = br; ++ arg->calc = *calc; ++ arg->ino = ino; ++ au_lcnt_inc(&br->br_count); ++ err = au_wkq_nowait(au_xino_call_do_new_async, arg, sb, AuWkq_NEST); ++ if (unlikely(err)) { ++ pr_err("wkq %d\n", err); ++ au_lcnt_dec(&br->br_count); ++ au_kfree_rcu(arg); ++ } ++ ++out: ++ return err; ++} ++ ++/* ++ * read @ino from xinofile for the specified branch{@sb, @bindex} ++ * at the position of @h_ino. ++ */ ++int au_xino_read(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t *ino) ++{ ++ int err; ++ ssize_t sz; ++ struct au_xi_calc calc; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ struct au_xino *xi; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos; ++ struct au_xi_writing *p; ++ ++ *ino = 0; ++ if (!au_opt_test(au_mntflags(sb), XINO)) ++ return 0; /* no xino */ ++ ++ err = 0; ++ au_xi_calc(sb, h_ino, &calc); ++ xi = au_sbr(sb, bindex)->br_xino; ++ file = au_xino_file(xi, calc.idx); ++ if (!file) { ++ hbl = &xi->xi_writing; ++ hlist_bl_lock(hbl); ++ au_hbl_for_each(pos, hbl) { ++ p = container_of(pos, struct au_xi_writing, node); ++ if (p->h_ino == h_ino) { ++ AuDbg("hi%llu, i%llu, found\n", ++ (u64)p->h_ino, (u64)p->ino); ++ *ino = p->ino; ++ break; ++ } ++ } ++ hlist_bl_unlock(hbl); ++ return 0; ++ } else if (vfsub_f_size_read(file) < calc.pos + sizeof(*ino)) ++ return 0; /* no xino */ ++ ++ sbinfo = au_sbi(sb); ++ sz = xino_fread(sbinfo->si_xread, file, ino, sizeof(*ino), &calc.pos); ++ if (sz == sizeof(*ino)) ++ return 0; /* success */ ++ ++ err = sz; ++ if (unlikely(sz >= 0)) { ++ err = -EIO; ++ AuIOErr("xino read error (%zd)\n", sz); ++ } ++ return err; ++} ++ ++static int au_xino_do_write(vfs_writef_t write, struct file *file, ++ struct au_xi_calc *calc, ino_t ino) ++{ ++ ssize_t sz; ++ ++ sz = xino_fwrite(write, file, &ino, sizeof(ino), &calc->pos); ++ if (sz == sizeof(ino)) ++ return 0; /* success */ ++ ++ AuIOErr("write failed (%zd)\n", sz); ++ return -EIO; ++} ++ ++/* ++ * write @ino to the xinofile for the specified branch{@sb, @bindex} ++ * at the position of @h_ino. ++ * even if @ino is zero, it is written to the xinofile and means no entry. ++ * if the size of the xino file on a specific filesystem exceeds the watermark, ++ * try truncating it. ++ */ ++int au_xino_write(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t ino) ++{ ++ int err; ++ unsigned int mnt_flags; ++ struct au_xi_calc calc; ++ struct file *file; ++ struct au_branch *br; ++ struct au_xino *xi; ++ struct au_xi_writing *p; ++ ++ SiMustAnyLock(sb); ++ ++ mnt_flags = au_mntflags(sb); ++ if (!au_opt_test(mnt_flags, XINO)) ++ return 0; ++ ++ au_xi_calc(sb, h_ino, &calc); ++ br = au_sbr(sb, bindex); ++ xi = br->br_xino; ++ file = au_xino_file(xi, calc.idx); ++ if (!file) { ++ /* store the inum pair into the list */ ++ p = kmalloc(sizeof(*p), GFP_NOFS | __GFP_NOFAIL); ++ p->h_ino = h_ino; ++ p->ino = ino; ++ au_hbl_add(&p->node, &xi->xi_writing); ++ ++ /* create and write a new xino file asynchronously */ ++ err = au_xino_new_async(sb, br, &calc, ino); ++ if (!err) ++ return 0; /* success */ ++ goto out; ++ } ++ ++ err = au_xino_do_write(au_sbi(sb)->si_xwrite, file, &calc, ino); ++ if (!err) { ++ br = au_sbr(sb, bindex); ++ if (au_opt_test(mnt_flags, TRUNC_XINO) ++ && au_test_fs_trunc_xino(au_br_sb(br))) ++ xino_try_trunc(sb, br); ++ return 0; /* success */ ++ } ++ ++out: ++ AuIOErr("write failed (%d)\n", err); ++ return -EIO; ++} ++ ++static ssize_t xino_fread_wkq(vfs_readf_t func, struct file *file, void *buf, ++ size_t size, loff_t *pos); ++ ++/* todo: unnecessary to support mmap_sem since kernel-space? */ ++ssize_t xino_fread(vfs_readf_t func, struct file *file, void *kbuf, size_t size, ++ loff_t *pos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ union { ++ void *k; ++ char __user *u; ++ } buf; ++ int i; ++ const int prevent_endless = 10; ++ ++ i = 0; ++ buf.k = kbuf; ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ do { ++ err = func(file, buf.u, size, pos); ++ if (err == -EINTR ++ && !au_wkq_test() ++ && fatal_signal_pending(current)) { ++ set_fs(oldfs); ++ err = xino_fread_wkq(func, file, kbuf, size, pos); ++ BUG_ON(err == -EINTR); ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ } ++ } while (i++ < prevent_endless ++ && (err == -EAGAIN || err == -EINTR)); ++ set_fs(oldfs); ++ ++#if 0 /* reserved for future use */ ++ if (err > 0) ++ fsnotify_access(file->f_path.dentry); ++#endif ++ ++ return err; ++} ++ ++struct xino_fread_args { ++ ssize_t *errp; ++ vfs_readf_t func; ++ struct file *file; ++ void *buf; ++ size_t size; ++ loff_t *pos; ++}; ++ ++static void call_xino_fread(void *args) ++{ ++ struct xino_fread_args *a = args; ++ *a->errp = xino_fread(a->func, a->file, a->buf, a->size, a->pos); ++} ++ ++static ssize_t xino_fread_wkq(vfs_readf_t func, struct file *file, void *buf, ++ size_t size, loff_t *pos) ++{ ++ ssize_t err; ++ int wkq_err; ++ struct xino_fread_args args = { ++ .errp = &err, ++ .func = func, ++ .file = file, ++ .buf = buf, ++ .size = size, ++ .pos = pos ++ }; ++ ++ wkq_err = au_wkq_wait(call_xino_fread, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ ++ return err; ++} ++ ++static ssize_t xino_fwrite_wkq(vfs_writef_t func, struct file *file, void *buf, ++ size_t size, loff_t *pos); ++ ++static ssize_t do_xino_fwrite(vfs_writef_t func, struct file *file, void *kbuf, ++ size_t size, loff_t *pos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ union { ++ void *k; ++ const char __user *u; ++ } buf; ++ int i; ++ const int prevent_endless = 10; ++ ++ i = 0; ++ buf.k = kbuf; ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ do { ++ err = func(file, buf.u, size, pos); ++ if (err == -EINTR ++ && !au_wkq_test() ++ && fatal_signal_pending(current)) { ++ set_fs(oldfs); ++ err = xino_fwrite_wkq(func, file, kbuf, size, pos); ++ BUG_ON(err == -EINTR); ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ } ++ } while (i++ < prevent_endless ++ && (err == -EAGAIN || err == -EINTR)); ++ set_fs(oldfs); ++ ++#if 0 /* reserved for future use */ ++ if (err > 0) ++ fsnotify_modify(file->f_path.dentry); ++#endif ++ ++ return err; ++} ++ ++struct do_xino_fwrite_args { ++ ssize_t *errp; ++ vfs_writef_t func; ++ struct file *file; ++ void *buf; ++ size_t size; ++ loff_t *pos; ++}; ++ ++static void call_do_xino_fwrite(void *args) ++{ ++ struct do_xino_fwrite_args *a = args; ++ *a->errp = do_xino_fwrite(a->func, a->file, a->buf, a->size, a->pos); ++} ++ ++static ssize_t xino_fwrite_wkq(vfs_writef_t func, struct file *file, void *buf, ++ size_t size, loff_t *pos) ++{ ++ ssize_t err; ++ int wkq_err; ++ struct do_xino_fwrite_args args = { ++ .errp = &err, ++ .func = func, ++ .file = file, ++ .buf = buf, ++ .size = size, ++ .pos = pos ++ }; ++ ++ /* ++ * it breaks RLIMIT_FSIZE and normal user's limit, ++ * users should care about quota and real 'filesystem full.' ++ */ ++ wkq_err = au_wkq_wait(call_do_xino_fwrite, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ ++ return err; ++} ++ ++ssize_t xino_fwrite(vfs_writef_t func, struct file *file, void *buf, ++ size_t size, loff_t *pos) ++{ ++ ssize_t err; ++ ++ if (rlimit(RLIMIT_FSIZE) == RLIM_INFINITY) { ++ lockdep_off(); ++ err = do_xino_fwrite(func, file, buf, size, pos); ++ lockdep_on(); ++ } else { ++ lockdep_off(); ++ err = xino_fwrite_wkq(func, file, buf, size, pos); ++ lockdep_on(); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * inode number bitmap ++ */ ++static const int page_bits = (int)PAGE_SIZE * BITS_PER_BYTE; ++static ino_t xib_calc_ino(unsigned long pindex, int bit) ++{ ++ ino_t ino; ++ ++ AuDebugOn(bit < 0 || page_bits <= bit); ++ ino = AUFS_FIRST_INO + pindex * page_bits + bit; ++ return ino; ++} ++ ++static void xib_calc_bit(ino_t ino, unsigned long *pindex, int *bit) ++{ ++ AuDebugOn(ino < AUFS_FIRST_INO); ++ ino -= AUFS_FIRST_INO; ++ *pindex = ino / page_bits; ++ *bit = ino % page_bits; ++} ++ ++static int xib_pindex(struct super_block *sb, unsigned long pindex) ++{ ++ int err; ++ loff_t pos; ++ ssize_t sz; ++ struct au_sbinfo *sbinfo; ++ struct file *xib; ++ unsigned long *p; ++ ++ sbinfo = au_sbi(sb); ++ MtxMustLock(&sbinfo->si_xib_mtx); ++ AuDebugOn(pindex > ULONG_MAX / PAGE_SIZE ++ || !au_opt_test(sbinfo->si_mntflags, XINO)); ++ ++ if (pindex == sbinfo->si_xib_last_pindex) ++ return 0; ++ ++ xib = sbinfo->si_xib; ++ p = sbinfo->si_xib_buf; ++ pos = sbinfo->si_xib_last_pindex; ++ pos *= PAGE_SIZE; ++ sz = xino_fwrite(sbinfo->si_xwrite, xib, p, PAGE_SIZE, &pos); ++ if (unlikely(sz != PAGE_SIZE)) ++ goto out; ++ ++ pos = pindex; ++ pos *= PAGE_SIZE; ++ if (vfsub_f_size_read(xib) >= pos + PAGE_SIZE) ++ sz = xino_fread(sbinfo->si_xread, xib, p, PAGE_SIZE, &pos); ++ else { ++ memset(p, 0, PAGE_SIZE); ++ sz = xino_fwrite(sbinfo->si_xwrite, xib, p, PAGE_SIZE, &pos); ++ } ++ if (sz == PAGE_SIZE) { ++ sbinfo->si_xib_last_pindex = pindex; ++ return 0; /* success */ ++ } ++ ++out: ++ AuIOErr1("write failed (%zd)\n", sz); ++ err = sz; ++ if (sz >= 0) ++ err = -EIO; ++ return err; ++} ++ ++static void au_xib_clear_bit(struct inode *inode) ++{ ++ int err, bit; ++ unsigned long pindex; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++ AuDebugOn(inode->i_nlink); ++ ++ sb = inode->i_sb; ++ xib_calc_bit(inode->i_ino, &pindex, &bit); ++ AuDebugOn(page_bits <= bit); ++ sbinfo = au_sbi(sb); ++ mutex_lock(&sbinfo->si_xib_mtx); ++ err = xib_pindex(sb, pindex); ++ if (!err) { ++ clear_bit(bit, sbinfo->si_xib_buf); ++ sbinfo->si_xib_next_bit = bit; ++ } ++ mutex_unlock(&sbinfo->si_xib_mtx); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * truncate a xino bitmap file ++ */ ++ ++/* todo: slow */ ++static int do_xib_restore(struct super_block *sb, struct file *file, void *page) ++{ ++ int err, bit; ++ ssize_t sz; ++ unsigned long pindex; ++ loff_t pos, pend; ++ struct au_sbinfo *sbinfo; ++ vfs_readf_t func; ++ ino_t *ino; ++ unsigned long *p; ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ MtxMustLock(&sbinfo->si_xib_mtx); ++ p = sbinfo->si_xib_buf; ++ func = sbinfo->si_xread; ++ pend = vfsub_f_size_read(file); ++ pos = 0; ++ while (pos < pend) { ++ sz = xino_fread(func, file, page, PAGE_SIZE, &pos); ++ err = sz; ++ if (unlikely(sz <= 0)) ++ goto out; ++ ++ err = 0; ++ for (ino = page; sz > 0; ino++, sz -= sizeof(ino)) { ++ if (unlikely(*ino < AUFS_FIRST_INO)) ++ continue; ++ ++ xib_calc_bit(*ino, &pindex, &bit); ++ AuDebugOn(page_bits <= bit); ++ err = xib_pindex(sb, pindex); ++ if (!err) ++ set_bit(bit, p); ++ else ++ goto out; ++ } ++ } ++ ++out: ++ return err; ++} ++ ++static int xib_restore(struct super_block *sb) ++{ ++ int err, i; ++ unsigned int nfile; ++ aufs_bindex_t bindex, bbot; ++ void *page; ++ struct au_branch *br; ++ struct au_xino *xi; ++ struct file *file; ++ ++ err = -ENOMEM; ++ page = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!page)) ++ goto out; ++ ++ err = 0; ++ bbot = au_sbbot(sb); ++ for (bindex = 0; !err && bindex <= bbot; bindex++) ++ if (!bindex || is_sb_shared(sb, bindex, bindex - 1) < 0) { ++ br = au_sbr(sb, bindex); ++ xi = br->br_xino; ++ nfile = xi->xi_nfile; ++ for (i = 0; i < nfile; i++) { ++ file = au_xino_file(xi, i); ++ if (file) ++ err = do_xib_restore(sb, file, page); ++ } ++ } else ++ AuDbg("skip shared b%d\n", bindex); ++ free_page((unsigned long)page); ++ ++out: ++ return err; ++} ++ ++int au_xib_trunc(struct super_block *sb) ++{ ++ int err; ++ ssize_t sz; ++ loff_t pos; ++ struct au_sbinfo *sbinfo; ++ unsigned long *p; ++ struct file *file; ++ ++ SiMustWriteLock(sb); ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ if (!au_opt_test(sbinfo->si_mntflags, XINO)) ++ goto out; ++ ++ file = sbinfo->si_xib; ++ if (vfsub_f_size_read(file) <= PAGE_SIZE) ++ goto out; ++ ++ file = au_xino_create2(sb, &sbinfo->si_xib->f_path, NULL); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = file; ++ ++ p = sbinfo->si_xib_buf; ++ memset(p, 0, PAGE_SIZE); ++ pos = 0; ++ sz = xino_fwrite(sbinfo->si_xwrite, sbinfo->si_xib, p, PAGE_SIZE, &pos); ++ if (unlikely(sz != PAGE_SIZE)) { ++ err = sz; ++ AuIOErr("err %d\n", err); ++ if (sz >= 0) ++ err = -EIO; ++ goto out; ++ } ++ ++ mutex_lock(&sbinfo->si_xib_mtx); ++ /* mnt_want_write() is unnecessary here */ ++ err = xib_restore(sb); ++ mutex_unlock(&sbinfo->si_xib_mtx); ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_xino *au_xino_alloc(unsigned int nfile) ++{ ++ struct au_xino *xi; ++ ++ xi = kzalloc(sizeof(*xi), GFP_NOFS); ++ if (unlikely(!xi)) ++ goto out; ++ xi->xi_nfile = nfile; ++ xi->xi_file = kcalloc(nfile, sizeof(*xi->xi_file), GFP_NOFS); ++ if (unlikely(!xi->xi_file)) ++ goto out_free; ++ ++ xi->xi_nondir.total = 8; /* initial size */ ++ xi->xi_nondir.array = kcalloc(xi->xi_nondir.total, sizeof(ino_t), ++ GFP_NOFS); ++ if (unlikely(!xi->xi_nondir.array)) ++ goto out_file; ++ ++ spin_lock_init(&xi->xi_nondir.spin); ++ init_waitqueue_head(&xi->xi_nondir.wqh); ++ mutex_init(&xi->xi_mtx); ++ INIT_HLIST_BL_HEAD(&xi->xi_writing); ++ atomic_set(&xi->xi_truncating, 0); ++ kref_init(&xi->xi_kref); ++ goto out; /* success */ ++ ++out_file: ++ au_kfree_try_rcu(xi->xi_file); ++out_free: ++ au_kfree_rcu(xi); ++ xi = NULL; ++out: ++ return xi; ++} ++ ++static int au_xino_init(struct au_branch *br, int idx, struct file *file) ++{ ++ int err; ++ struct au_xino *xi; ++ ++ err = 0; ++ xi = au_xino_alloc(idx + 1); ++ if (unlikely(!xi)) { ++ err = -ENOMEM; ++ goto out; ++ } ++ ++ if (file) ++ get_file(file); ++ xi->xi_file[idx] = file; ++ AuDebugOn(br->br_xino); ++ br->br_xino = xi; ++ ++out: ++ return err; ++} ++ ++static void au_xino_release(struct kref *kref) ++{ ++ struct au_xino *xi; ++ int i; ++ unsigned long ul; ++ struct hlist_bl_head *hbl; ++ struct hlist_bl_node *pos, *n; ++ struct au_xi_writing *p; ++ ++ xi = container_of(kref, struct au_xino, xi_kref); ++ for (i = 0; i < xi->xi_nfile; i++) ++ if (xi->xi_file[i]) ++ fput(xi->xi_file[i]); ++ for (i = xi->xi_nondir.total - 1; i >= 0; i--) ++ AuDebugOn(xi->xi_nondir.array[i]); ++ mutex_destroy(&xi->xi_mtx); ++ hbl = &xi->xi_writing; ++ ul = au_hbl_count(hbl); ++ if (unlikely(ul)) { ++ pr_warn("xi_writing %lu\n", ul); ++ hlist_bl_lock(hbl); ++ hlist_bl_for_each_entry_safe(p, pos, n, hbl, node) { ++ hlist_bl_del(&p->node); ++ /* kmemleak reported au_kfree_rcu() doesn't free it */ ++ kfree(p); ++ } ++ hlist_bl_unlock(hbl); ++ } ++ au_kfree_try_rcu(xi->xi_file); ++ au_kfree_try_rcu(xi->xi_nondir.array); ++ au_kfree_rcu(xi); ++} ++ ++int au_xino_put(struct au_branch *br) ++{ ++ int ret; ++ struct au_xino *xi; ++ ++ ret = 0; ++ xi = br->br_xino; ++ if (xi) { ++ br->br_xino = NULL; ++ ret = kref_put(&xi->xi_kref, au_xino_release); ++ } ++ ++ return ret; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * xino mount option handlers ++ */ ++ ++/* xino bitmap */ ++static void xino_clear_xib(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ /* unnecessary to clear sbinfo->si_xread and ->si_xwrite */ ++ if (sbinfo->si_xib) ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = NULL; ++ if (sbinfo->si_xib_buf) ++ free_page((unsigned long)sbinfo->si_xib_buf); ++ sbinfo->si_xib_buf = NULL; ++} ++ ++static int au_xino_set_xib(struct super_block *sb, struct path *path) ++{ ++ int err; ++ loff_t pos; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ struct super_block *xi_sb; ++ ++ SiMustWriteLock(sb); ++ ++ sbinfo = au_sbi(sb); ++ file = au_xino_create2(sb, path, sbinfo->si_xib); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ if (sbinfo->si_xib) ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = file; ++ sbinfo->si_xread = vfs_readf(file); ++ sbinfo->si_xwrite = vfs_writef(file); ++ xi_sb = file_inode(file)->i_sb; ++ sbinfo->si_ximaxent = xi_sb->s_maxbytes; ++ if (unlikely(sbinfo->si_ximaxent < PAGE_SIZE)) { ++ err = -EIO; ++ pr_err("s_maxbytes(%llu) on %s is too small\n", ++ (u64)sbinfo->si_ximaxent, au_sbtype(xi_sb)); ++ goto out_unset; ++ } ++ sbinfo->si_ximaxent /= sizeof(ino_t); ++ ++ err = -ENOMEM; ++ if (!sbinfo->si_xib_buf) ++ sbinfo->si_xib_buf = (void *)get_zeroed_page(GFP_NOFS); ++ if (unlikely(!sbinfo->si_xib_buf)) ++ goto out_unset; ++ ++ sbinfo->si_xib_last_pindex = 0; ++ sbinfo->si_xib_next_bit = 0; ++ if (vfsub_f_size_read(file) < PAGE_SIZE) { ++ pos = 0; ++ err = xino_fwrite(sbinfo->si_xwrite, file, sbinfo->si_xib_buf, ++ PAGE_SIZE, &pos); ++ if (unlikely(err != PAGE_SIZE)) ++ goto out_free; ++ } ++ err = 0; ++ goto out; /* success */ ++ ++out_free: ++ if (sbinfo->si_xib_buf) ++ free_page((unsigned long)sbinfo->si_xib_buf); ++ sbinfo->si_xib_buf = NULL; ++ if (err >= 0) ++ err = -EIO; ++out_unset: ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = NULL; ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* xino for each branch */ ++static void xino_clear_br(struct super_block *sb) ++{ ++ aufs_bindex_t bindex, bbot; ++ struct au_branch *br; ++ ++ bbot = au_sbbot(sb); ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ AuDebugOn(!br); ++ au_xino_put(br); ++ } ++} ++ ++static void au_xino_set_br_shared(struct super_block *sb, struct au_branch *br, ++ aufs_bindex_t bshared) ++{ ++ struct au_branch *brshared; ++ ++ brshared = au_sbr(sb, bshared); ++ AuDebugOn(!brshared->br_xino); ++ AuDebugOn(!brshared->br_xino->xi_file); ++ if (br->br_xino != brshared->br_xino) { ++ au_xino_get(brshared); ++ au_xino_put(br); ++ br->br_xino = brshared->br_xino; ++ } ++} ++ ++struct au_xino_do_set_br { ++ vfs_writef_t writef; ++ struct au_branch *br; ++ ino_t h_ino; ++ aufs_bindex_t bshared; ++}; ++ ++static int au_xino_do_set_br(struct super_block *sb, struct path *path, ++ struct au_xino_do_set_br *args) ++{ ++ int err; ++ struct au_xi_calc calc; ++ struct file *file; ++ struct au_branch *br; ++ struct au_xi_new xinew = { ++ .base = path ++ }; ++ ++ br = args->br; ++ xinew.xi = br->br_xino; ++ au_xi_calc(sb, args->h_ino, &calc); ++ xinew.copy_src = au_xino_file(xinew.xi, calc.idx); ++ if (args->bshared >= 0) ++ /* shared xino */ ++ au_xino_set_br_shared(sb, br, args->bshared); ++ else if (!xinew.xi) { ++ /* new xino */ ++ err = au_xino_init(br, calc.idx, xinew.copy_src); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ /* force re-creating */ ++ xinew.xi = br->br_xino; ++ xinew.idx = calc.idx; ++ mutex_lock(&xinew.xi->xi_mtx); ++ file = au_xi_new(sb, &xinew); ++ mutex_unlock(&xinew.xi->xi_mtx); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ AuDebugOn(!file); ++ ++ err = au_xino_do_write(args->writef, file, &calc, AUFS_ROOT_INO); ++ if (unlikely(err)) ++ au_xino_put(br); ++ ++out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int au_xino_set_br(struct super_block *sb, struct path *path) ++{ ++ int err; ++ aufs_bindex_t bindex, bbot; ++ struct au_xino_do_set_br args; ++ struct inode *inode; ++ ++ SiMustWriteLock(sb); ++ ++ bbot = au_sbbot(sb); ++ inode = d_inode(sb->s_root); ++ args.writef = au_sbi(sb)->si_xwrite; ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ args.h_ino = au_h_iptr(inode, bindex)->i_ino; ++ args.br = au_sbr(sb, bindex); ++ args.bshared = is_sb_shared(sb, bindex, bindex - 1); ++ err = au_xino_do_set_br(sb, path, &args); ++ if (unlikely(err)) ++ break; ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_xino_clr(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ au_xigen_clr(sb); ++ xino_clear_xib(sb); ++ xino_clear_br(sb); ++ dbgaufs_brs_del(sb, 0); ++ sbinfo = au_sbi(sb); ++ /* lvalue, do not call au_mntflags() */ ++ au_opt_clr(sbinfo->si_mntflags, XINO); ++} ++ ++int au_xino_set(struct super_block *sb, struct au_opt_xino *xiopt, int remount) ++{ ++ int err, skip; ++ struct dentry *dentry, *parent, *cur_dentry, *cur_parent; ++ struct qstr *dname, *cur_name; ++ struct file *cur_xino; ++ struct au_sbinfo *sbinfo; ++ struct path *path, *cur_path; ++ ++ SiMustWriteLock(sb); ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ path = &xiopt->file->f_path; ++ dentry = path->dentry; ++ parent = dget_parent(dentry); ++ if (remount) { ++ skip = 0; ++ cur_xino = sbinfo->si_xib; ++ if (cur_xino) { ++ cur_path = &cur_xino->f_path; ++ cur_dentry = cur_path->dentry; ++ cur_parent = dget_parent(cur_dentry); ++ cur_name = &cur_dentry->d_name; ++ dname = &dentry->d_name; ++ skip = (cur_parent == parent ++ && au_qstreq(dname, cur_name)); ++ dput(cur_parent); ++ } ++ if (skip) ++ goto out; ++ } ++ ++ au_opt_set(sbinfo->si_mntflags, XINO); ++ err = au_xino_set_xib(sb, path); ++ /* si_x{read,write} are set */ ++ if (!err) ++ err = au_xigen_set(sb, path); ++ if (!err) ++ err = au_xino_set_br(sb, path); ++ if (!err) { ++ dbgaufs_brs_add(sb, 0, /*topdown*/1); ++ goto out; /* success */ ++ } ++ ++ /* reset all */ ++ AuIOErr("failed setting xino(%d).\n", err); ++ au_xino_clr(sb); ++ ++out: ++ dput(parent); ++ return err; ++} ++ ++/* ++ * create a xinofile at the default place/path. ++ */ ++struct file *au_xino_def(struct super_block *sb) ++{ ++ struct file *file; ++ char *page, *p; ++ struct au_branch *br; ++ struct super_block *h_sb; ++ struct path path; ++ aufs_bindex_t bbot, bindex, bwr; ++ ++ br = NULL; ++ bbot = au_sbbot(sb); ++ bwr = -1; ++ for (bindex = 0; bindex <= bbot; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_writable(br->br_perm) ++ && !au_test_fs_bad_xino(au_br_sb(br))) { ++ bwr = bindex; ++ break; ++ } ++ } ++ ++ if (bwr >= 0) { ++ file = ERR_PTR(-ENOMEM); ++ page = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!page)) ++ goto out; ++ path.mnt = au_br_mnt(br); ++ path.dentry = au_h_dptr(sb->s_root, bwr); ++ p = d_path(&path, page, PATH_MAX - sizeof(AUFS_XINO_FNAME)); ++ file = (void *)p; ++ if (!IS_ERR(p)) { ++ strcat(p, "/" AUFS_XINO_FNAME); ++ AuDbg("%s\n", p); ++ file = au_xino_create(sb, p, /*silent*/0, /*wbrtop*/1); ++ } ++ free_page((unsigned long)page); ++ } else { ++ file = au_xino_create(sb, AUFS_XINO_DEFPATH, /*silent*/0, ++ /*wbrtop*/0); ++ if (IS_ERR(file)) ++ goto out; ++ h_sb = file->f_path.dentry->d_sb; ++ if (unlikely(au_test_fs_bad_xino(h_sb))) { ++ pr_err("xino doesn't support %s(%s)\n", ++ AUFS_XINO_DEFPATH, au_sbtype(h_sb)); ++ fput(file); ++ file = ERR_PTR(-EINVAL); ++ } ++ } ++ ++out: ++ return file; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * initialize the xinofile for the specified branch @br ++ * at the place/path where @base_file indicates. ++ * test whether another branch is on the same filesystem or not, ++ * if found then share the xinofile with another branch. ++ */ ++int au_xino_init_br(struct super_block *sb, struct au_branch *br, ino_t h_ino, ++ struct path *base) ++{ ++ int err; ++ struct au_xino_do_set_br args = { ++ .h_ino = h_ino, ++ .br = br ++ }; ++ ++ args.writef = au_sbi(sb)->si_xwrite; ++ args.bshared = sbr_find_shared(sb, /*btop*/0, au_sbbot(sb), ++ au_br_sb(br)); ++ err = au_xino_do_set_br(sb, base, &args); ++ if (unlikely(err)) ++ au_xino_put(br); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * get an unused inode number from bitmap ++ */ ++ino_t au_xino_new_ino(struct super_block *sb) ++{ ++ ino_t ino; ++ unsigned long *p, pindex, ul, pend; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ int free_bit, err; ++ ++ if (!au_opt_test(au_mntflags(sb), XINO)) ++ return iunique(sb, AUFS_FIRST_INO); ++ ++ sbinfo = au_sbi(sb); ++ mutex_lock(&sbinfo->si_xib_mtx); ++ p = sbinfo->si_xib_buf; ++ free_bit = sbinfo->si_xib_next_bit; ++ if (free_bit < page_bits && !test_bit(free_bit, p)) ++ goto out; /* success */ ++ free_bit = find_first_zero_bit(p, page_bits); ++ if (free_bit < page_bits) ++ goto out; /* success */ ++ ++ pindex = sbinfo->si_xib_last_pindex; ++ for (ul = pindex - 1; ul < ULONG_MAX; ul--) { ++ err = xib_pindex(sb, ul); ++ if (unlikely(err)) ++ goto out_err; ++ free_bit = find_first_zero_bit(p, page_bits); ++ if (free_bit < page_bits) ++ goto out; /* success */ ++ } ++ ++ file = sbinfo->si_xib; ++ pend = vfsub_f_size_read(file) / PAGE_SIZE; ++ for (ul = pindex + 1; ul <= pend; ul++) { ++ err = xib_pindex(sb, ul); ++ if (unlikely(err)) ++ goto out_err; ++ free_bit = find_first_zero_bit(p, page_bits); ++ if (free_bit < page_bits) ++ goto out; /* success */ ++ } ++ BUG(); ++ ++out: ++ set_bit(free_bit, p); ++ sbinfo->si_xib_next_bit = free_bit + 1; ++ pindex = sbinfo->si_xib_last_pindex; ++ mutex_unlock(&sbinfo->si_xib_mtx); ++ ino = xib_calc_ino(pindex, free_bit); ++ AuDbg("i%lu\n", (unsigned long)ino); ++ return ino; ++out_err: ++ mutex_unlock(&sbinfo->si_xib_mtx); ++ AuDbg("i0\n"); ++ return 0; ++} ++ ++/* for s_op->delete_inode() */ ++void au_xino_delete_inode(struct inode *inode, const int unlinked) ++{ ++ int err; ++ unsigned int mnt_flags; ++ aufs_bindex_t bindex, bbot, bi; ++ unsigned char try_trunc; ++ struct au_iinfo *iinfo; ++ struct super_block *sb; ++ struct au_hinode *hi; ++ struct inode *h_inode; ++ struct au_branch *br; ++ vfs_writef_t xwrite; ++ struct au_xi_calc calc; ++ struct file *file; ++ ++ AuDebugOn(au_is_bad_inode(inode)); ++ ++ sb = inode->i_sb; ++ mnt_flags = au_mntflags(sb); ++ if (!au_opt_test(mnt_flags, XINO) ++ || inode->i_ino == AUFS_ROOT_INO) ++ return; ++ ++ if (unlinked) { ++ au_xigen_inc(inode); ++ au_xib_clear_bit(inode); ++ } ++ ++ iinfo = au_ii(inode); ++ bindex = iinfo->ii_btop; ++ if (bindex < 0) ++ return; ++ ++ xwrite = au_sbi(sb)->si_xwrite; ++ try_trunc = !!au_opt_test(mnt_flags, TRUNC_XINO); ++ hi = au_hinode(iinfo, bindex); ++ bbot = iinfo->ii_bbot; ++ for (; bindex <= bbot; bindex++, hi++) { ++ h_inode = hi->hi_inode; ++ if (!h_inode ++ || (!unlinked && h_inode->i_nlink)) ++ continue; ++ ++ /* inode may not be revalidated */ ++ bi = au_br_index(sb, hi->hi_id); ++ if (bi < 0) ++ continue; ++ ++ br = au_sbr(sb, bi); ++ au_xi_calc(sb, h_inode->i_ino, &calc); ++ file = au_xino_file(br->br_xino, calc.idx); ++ if (IS_ERR_OR_NULL(file)) ++ continue; ++ ++ err = au_xino_do_write(xwrite, file, &calc, /*ino*/0); ++ if (!err && try_trunc ++ && au_test_fs_trunc_xino(au_br_sb(br))) ++ xino_try_trunc(sb, br); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_xinondir_find(struct au_xino *xi, ino_t h_ino) ++{ ++ int found, total, i; ++ ++ found = -1; ++ total = xi->xi_nondir.total; ++ for (i = 0; i < total; i++) { ++ if (xi->xi_nondir.array[i] != h_ino) ++ continue; ++ found = i; ++ break; ++ } ++ ++ return found; ++} ++ ++static int au_xinondir_expand(struct au_xino *xi) ++{ ++ int err, sz; ++ ino_t *p; ++ ++ BUILD_BUG_ON(KMALLOC_MAX_SIZE > INT_MAX); ++ ++ err = -ENOMEM; ++ sz = xi->xi_nondir.total * sizeof(ino_t); ++ if (unlikely(sz > KMALLOC_MAX_SIZE / 2)) ++ goto out; ++ p = au_kzrealloc(xi->xi_nondir.array, sz, sz << 1, GFP_ATOMIC, ++ /*may_shrink*/0); ++ if (p) { ++ xi->xi_nondir.array = p; ++ xi->xi_nondir.total <<= 1; ++ AuDbg("xi_nondir.total %d\n", xi->xi_nondir.total); ++ err = 0; ++ } ++ ++out: ++ return err; ++} ++ ++void au_xinondir_leave(struct super_block *sb, aufs_bindex_t bindex, ++ ino_t h_ino, int idx) ++{ ++ struct au_xino *xi; ++ ++ AuDebugOn(!au_opt_test(au_mntflags(sb), XINO)); ++ xi = au_sbr(sb, bindex)->br_xino; ++ AuDebugOn(idx < 0 || xi->xi_nondir.total <= idx); ++ ++ spin_lock(&xi->xi_nondir.spin); ++ AuDebugOn(xi->xi_nondir.array[idx] != h_ino); ++ xi->xi_nondir.array[idx] = 0; ++ spin_unlock(&xi->xi_nondir.spin); ++ wake_up_all(&xi->xi_nondir.wqh); ++} ++ ++int au_xinondir_enter(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ int *idx) ++{ ++ int err, found, empty; ++ struct au_xino *xi; ++ ++ err = 0; ++ *idx = -1; ++ if (!au_opt_test(au_mntflags(sb), XINO)) ++ goto out; /* no xino */ ++ ++ xi = au_sbr(sb, bindex)->br_xino; ++ ++again: ++ spin_lock(&xi->xi_nondir.spin); ++ found = au_xinondir_find(xi, h_ino); ++ if (found == -1) { ++ empty = au_xinondir_find(xi, /*h_ino*/0); ++ if (empty == -1) { ++ empty = xi->xi_nondir.total; ++ err = au_xinondir_expand(xi); ++ if (unlikely(err)) ++ goto out_unlock; ++ } ++ xi->xi_nondir.array[empty] = h_ino; ++ *idx = empty; ++ } else { ++ spin_unlock(&xi->xi_nondir.spin); ++ wait_event(xi->xi_nondir.wqh, ++ xi->xi_nondir.array[found] != h_ino); ++ goto again; ++ } ++ ++out_unlock: ++ spin_unlock(&xi->xi_nondir.spin); ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_xino_path(struct seq_file *seq, struct file *file) ++{ ++ int err; ++ ++ err = au_seq_path(seq, &file->f_path); ++ if (unlikely(err)) ++ goto out; ++ ++#define Deleted "\\040(deleted)" ++ seq->count -= sizeof(Deleted) - 1; ++ AuDebugOn(memcmp(seq->buf + seq->count, Deleted, ++ sizeof(Deleted) - 1)); ++#undef Deleted ++ ++out: ++ return err; ++} +diff --git a/fs/dcache.c b/fs/dcache.c +index 361ea7ab30ea..e6e467c9e86c 100644 +--- a/fs/dcache.c ++++ b/fs/dcache.c +@@ -1285,7 +1285,7 @@ enum d_walk_ret { + * + * The @enter() callbacks are called with d_lock held. + */ +-static void d_walk(struct dentry *parent, void *data, ++void d_walk(struct dentry *parent, void *data, + enum d_walk_ret (*enter)(void *, struct dentry *)) + { + struct dentry *this_parent; +@@ -1390,6 +1390,7 @@ static void d_walk(struct dentry *parent, void *data, + seq = 1; + goto again; + } ++EXPORT_SYMBOL_GPL(d_walk); + + struct check_mount { + struct vfsmount *mnt; +@@ -2935,6 +2936,7 @@ void d_exchange(struct dentry *dentry1, struct dentry *dentry2) + + write_sequnlock(&rename_lock); + } ++EXPORT_SYMBOL_GPL(d_exchange); + + /** + * d_ancestor - search for an ancestor +diff --git a/fs/exec.c b/fs/exec.c +index e6e8a9a70327..a72a0dbfcc45 100644 +--- a/fs/exec.c ++++ b/fs/exec.c +@@ -111,6 +111,7 @@ bool path_noexec(const struct path *path) + return (path->mnt->mnt_flags & MNT_NOEXEC) || + (path->mnt->mnt_sb->s_iflags & SB_I_NOEXEC); + } ++EXPORT_SYMBOL_GPL(path_noexec); + + #ifdef CONFIG_USELIB + /* +diff --git a/fs/fcntl.c b/fs/fcntl.c +index 2e4c0fa2074b..f2c90a416b75 100644 +--- a/fs/fcntl.c ++++ b/fs/fcntl.c +@@ -32,7 +32,7 @@ + + #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME) + +-static int setfl(int fd, struct file * filp, unsigned long arg) ++int setfl(int fd, struct file *filp, unsigned long arg) + { + struct inode * inode = file_inode(filp); + int error = 0; +@@ -63,6 +63,8 @@ static int setfl(int fd, struct file * filp, unsigned long arg) + + if (filp->f_op->check_flags) + error = filp->f_op->check_flags(arg); ++ if (!error && filp->f_op->setfl) ++ error = filp->f_op->setfl(filp, arg); + if (error) + return error; + +@@ -83,6 +85,7 @@ static int setfl(int fd, struct file * filp, unsigned long arg) + out: + return error; + } ++EXPORT_SYMBOL_GPL(setfl); + + static void f_modown(struct file *filp, struct pid *pid, enum pid_type type, + int force) +diff --git a/fs/file_table.c b/fs/file_table.c +index 656647f9575a..6e11f3dc333f 100644 +--- a/fs/file_table.c ++++ b/fs/file_table.c +@@ -162,6 +162,7 @@ struct file *alloc_empty_file(int flags, const struct cred *cred) + } + return ERR_PTR(-ENFILE); + } ++EXPORT_SYMBOL_GPL(alloc_empty_file); + + /* + * Variant of alloc_empty_file() that doesn't check and modify nr_files. +@@ -376,6 +377,7 @@ void __fput_sync(struct file *file) + } + + EXPORT_SYMBOL(fput); ++EXPORT_SYMBOL_GPL(__fput_sync); + + void __init files_init(void) + { +diff --git a/fs/inode.c b/fs/inode.c +index 72c4c347afb7..07d0cb8d5c98 100644 +--- a/fs/inode.c ++++ b/fs/inode.c +@@ -1768,12 +1768,13 @@ EXPORT_SYMBOL(generic_update_time); + * This does the actual work of updating an inodes time or version. Must have + * had called mnt_want_write() before calling this. + */ +-static int update_time(struct inode *inode, struct timespec64 *time, int flags) ++int update_time(struct inode *inode, struct timespec64 *time, int flags) + { + if (inode->i_op->update_time) + return inode->i_op->update_time(inode, time, flags); + return generic_update_time(inode, time, flags); + } ++EXPORT_SYMBOL_GPL(update_time); + + /** + * touch_atime - update the access time +diff --git a/fs/namespace.c b/fs/namespace.c +index 4a0f600a3328..2b7e1ac8c4c5 100644 +--- a/fs/namespace.c ++++ b/fs/namespace.c +@@ -431,6 +431,7 @@ void __mnt_drop_write(struct vfsmount *mnt) + mnt_dec_writers(real_mount(mnt)); + preempt_enable(); + } ++EXPORT_SYMBOL_GPL(__mnt_drop_write); + + /** + * mnt_drop_write - give up write access to a mount +@@ -792,6 +793,13 @@ static inline int check_mnt(struct mount *mnt) + return mnt->mnt_ns == current->nsproxy->mnt_ns; + } + ++/* for aufs, CONFIG_AUFS_BR_FUSE */ ++int is_current_mnt_ns(struct vfsmount *mnt) ++{ ++ return check_mnt(real_mount(mnt)); ++} ++EXPORT_SYMBOL_GPL(is_current_mnt_ns); ++ + /* + * vfsmount lock must be held for write + */ +@@ -1955,6 +1963,7 @@ int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg, + } + return 0; + } ++EXPORT_SYMBOL_GPL(iterate_mounts); + + static void lock_mnt_tree(struct mount *mnt) + { +diff --git a/fs/notify/group.c b/fs/notify/group.c +index a4a4b1c64d32..86dc2efb1850 100644 +--- a/fs/notify/group.c ++++ b/fs/notify/group.c +@@ -100,6 +100,7 @@ void fsnotify_get_group(struct fsnotify_group *group) + { + refcount_inc(&group->refcnt); + } ++EXPORT_SYMBOL_GPL(fsnotify_get_group); + + /* + * Drop a reference to a group. Free it if it's through. +diff --git a/fs/open.c b/fs/open.c +index 6cd48a61cda3..bb623ca6397e 100644 +--- a/fs/open.c ++++ b/fs/open.c +@@ -65,6 +65,7 @@ int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs, + inode_unlock(dentry->d_inode); + return ret; + } ++EXPORT_SYMBOL_GPL(do_truncate); + + long vfs_truncate(const struct path *path, loff_t length) + { +diff --git a/fs/proc/base.c b/fs/proc/base.c +index d86c0afc8a85..ae484a4d2070 100644 +--- a/fs/proc/base.c ++++ b/fs/proc/base.c +@@ -2170,7 +2170,7 @@ static int map_files_get_link(struct dentry *dentry, struct path *path) + rc = -ENOENT; + vma = find_exact_vma(mm, vm_start, vm_end); + if (vma && vma->vm_file) { +- *path = vma->vm_file->f_path; ++ *path = vma_pr_or_file(vma)->f_path; + path_get(path); + rc = 0; + } +diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c +index 13452b32e2bd..38acccfef9d4 100644 +--- a/fs/proc/nommu.c ++++ b/fs/proc/nommu.c +@@ -40,7 +40,10 @@ static int nommu_region_show(struct seq_file *m, struct vm_region *region) + file = region->vm_file; + + if (file) { +- struct inode *inode = file_inode(region->vm_file); ++ struct inode *inode; ++ ++ file = vmr_pr_or_file(region); ++ inode = file_inode(file); + dev = inode->i_sb->s_dev; + ino = inode->i_ino; + } +diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c +index dbda4499a859..5f6fdf574d83 100644 +--- a/fs/proc/task_mmu.c ++++ b/fs/proc/task_mmu.c +@@ -280,7 +280,10 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma) + const char *name = NULL; + + if (file) { +- struct inode *inode = file_inode(vma->vm_file); ++ struct inode *inode; ++ ++ file = vma_pr_or_file(vma); ++ inode = file_inode(file); + dev = inode->i_sb->s_dev; + ino = inode->i_ino; + pgoff = ((loff_t)vma->vm_pgoff) << PAGE_SHIFT; +@@ -1793,7 +1796,7 @@ static int show_numa_map(struct seq_file *m, void *v) + struct proc_maps_private *proc_priv = &numa_priv->proc_maps; + struct vm_area_struct *vma = v; + struct numa_maps *md = &numa_priv->md; +- struct file *file = vma->vm_file; ++ struct file *file = vma_pr_or_file(vma); + struct mm_struct *mm = vma->vm_mm; + struct mempolicy *pol; + char buffer[64]; +diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c +index a6d21fc0033c..02c2de31196e 100644 +--- a/fs/proc/task_nommu.c ++++ b/fs/proc/task_nommu.c +@@ -155,7 +155,10 @@ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma) + file = vma->vm_file; + + if (file) { +- struct inode *inode = file_inode(vma->vm_file); ++ struct inode *inode; ++ ++ file = vma_pr_or_file(vma); ++ inode = file_inode(file); + dev = inode->i_sb->s_dev; + ino = inode->i_ino; + pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT; +diff --git a/fs/read_write.c b/fs/read_write.c +index 4fb797822567..71397019587a 100644 +--- a/fs/read_write.c ++++ b/fs/read_write.c +@@ -488,6 +488,7 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos) + inc_syscr(current); + return ret; + } ++EXPORT_SYMBOL_GPL(vfs_read); + + static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos) + { +@@ -508,6 +509,30 @@ static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t + } + + /* caller is responsible for file_start_write/file_end_write */ ++vfs_readf_t vfs_readf(struct file *file) ++{ ++ const struct file_operations *fop = file->f_op; ++ ++ if (fop->read) ++ return fop->read; ++ if (fop->read_iter) ++ return new_sync_read; ++ return ERR_PTR(-ENOSYS); /* doesn't have ->read(|_iter)() op */ ++} ++EXPORT_SYMBOL_GPL(vfs_readf); ++ ++vfs_writef_t vfs_writef(struct file *file) ++{ ++ const struct file_operations *fop = file->f_op; ++ ++ if (fop->write) ++ return fop->write; ++ if (fop->write_iter) ++ return new_sync_write; ++ return ERR_PTR(-ENOSYS); /* doesn't have ->write(|_iter)() op */ ++} ++EXPORT_SYMBOL_GPL(vfs_writef); ++ + ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos) + { + mm_segment_t old_fs; +@@ -586,6 +611,7 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_ + file_end_write(file); + return ret; + } ++EXPORT_SYMBOL_GPL(vfs_write); + + /* file_ppos returns &file->f_pos or NULL if file is stream */ + static inline loff_t *file_ppos(struct file *file) +diff --git a/fs/splice.c b/fs/splice.c +index d7c8a7c4db07..663e01ab2779 100644 +--- a/fs/splice.c ++++ b/fs/splice.c +@@ -839,8 +839,8 @@ EXPORT_SYMBOL(generic_splice_sendpage); + /* + * Attempt to initiate a splice from pipe to file. + */ +-static long do_splice_from(struct pipe_inode_info *pipe, struct file *out, +- loff_t *ppos, size_t len, unsigned int flags) ++long do_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags) + { + if (out->f_op->splice_write) + return out->f_op->splice_write(pipe, out, ppos, len, flags); +@@ -850,9 +850,9 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out, + /* + * Attempt to initiate a splice from a file to a pipe. + */ +-static long do_splice_to(struct file *in, loff_t *ppos, +- struct pipe_inode_info *pipe, size_t len, +- unsigned int flags) ++long do_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags) + { + int ret; + +@@ -870,6 +870,7 @@ static long do_splice_to(struct file *in, loff_t *ppos, + return in->f_op->splice_read(in, ppos, pipe, len, flags); + return default_file_splice_read(in, ppos, pipe, len, flags); + } ++EXPORT_SYMBOL_GPL(do_splice_from); + + /** + * splice_direct_to_actor - splices data directly between two non-pipes +@@ -1016,6 +1017,7 @@ static int direct_splice_actor(struct pipe_inode_info *pipe, + return do_splice_from(pipe, file, sd->opos, sd->total_len, + sd->flags); + } ++EXPORT_SYMBOL_GPL(do_splice_to); + + /** + * do_splice_direct - splices data directly between two files +diff --git a/fs/sync.c b/fs/sync.c +index 1373a610dc78..fa5c7fba7f1b 100644 +--- a/fs/sync.c ++++ b/fs/sync.c +@@ -28,7 +28,7 @@ + * wait == 1 case since in that case write_inode() functions do + * sync_dirty_buffer() and thus effectively write one block at a time. + */ +-static int __sync_filesystem(struct super_block *sb, int wait) ++int __sync_filesystem(struct super_block *sb, int wait) + { + if (wait) + sync_inodes_sb(sb); +@@ -39,6 +39,7 @@ static int __sync_filesystem(struct super_block *sb, int wait) + sb->s_op->sync_fs(sb, wait); + return __sync_blockdev(sb->s_bdev, wait); + } ++EXPORT_SYMBOL_GPL(__sync_filesystem); + + /* + * Write out and wait upon all dirty data associated with this +diff --git a/fs/xattr.c b/fs/xattr.c +index 95f38f57347f..f01b5bd9c102 100644 +--- a/fs/xattr.c ++++ b/fs/xattr.c +@@ -333,6 +333,7 @@ vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value, + *xattr_value = value; + return error; + } ++EXPORT_SYMBOL_GPL(vfs_getxattr_alloc); + + ssize_t + __vfs_getxattr(struct dentry *dentry, struct inode *inode, const char *name, +diff --git a/include/linux/fs.h b/include/linux/fs.h +index f5abba86107d..0b008da5678d 100644 +--- a/include/linux/fs.h ++++ b/include/linux/fs.h +@@ -1360,6 +1360,7 @@ extern void fasync_free(struct fasync_struct *); + /* can be called from interrupts */ + extern void kill_fasync(struct fasync_struct **, int, int); + ++extern int setfl(int fd, struct file *filp, unsigned long arg); + extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force); + extern int f_setown(struct file *filp, unsigned long arg, int force); + extern void f_delown(struct file *filp); +@@ -1848,6 +1849,7 @@ struct file_operations { + ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); + unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); + int (*check_flags)(int); ++ int (*setfl)(struct file *, unsigned long); + int (*flock) (struct file *, int, struct file_lock *); + ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); + ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); +@@ -1918,6 +1920,12 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector, + struct iovec *fast_pointer, + struct iovec **ret_pointer); + ++typedef ssize_t (*vfs_readf_t)(struct file *, char __user *, size_t, loff_t *); ++typedef ssize_t (*vfs_writef_t)(struct file *, const char __user *, size_t, ++ loff_t *); ++vfs_readf_t vfs_readf(struct file *file); ++vfs_writef_t vfs_writef(struct file *file); ++ + extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *); + extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *); + extern ssize_t vfs_readv(struct file *, const struct iovec __user *, +@@ -2352,6 +2360,7 @@ extern int current_umask(void); + extern void ihold(struct inode * inode); + extern void iput(struct inode *); + extern int generic_update_time(struct inode *, struct timespec64 *, int); ++extern int update_time(struct inode *, struct timespec64 *, int); + + /* /sys/fs */ + extern struct kobject *fs_kobj; +@@ -2633,6 +2642,7 @@ static inline bool sb_is_blkdev_sb(struct super_block *sb) + return false; + } + #endif ++extern int __sync_filesystem(struct super_block *, int); + extern int sync_filesystem(struct super_block *); + extern const struct file_operations def_blk_fops; + extern const struct file_operations def_chr_fops; +diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h +index 8fce5c98a4b0..c1a3f172e97a 100644 +--- a/include/linux/lockdep.h ++++ b/include/linux/lockdep.h +@@ -395,6 +395,8 @@ static inline int lockdep_match_key(struct lockdep_map *lock, + return lock->key == key; + } + ++struct lock_class *lockdep_hlock_class(struct held_lock *hlock); ++ + /* + * Acquire a lock. + * +@@ -540,6 +542,7 @@ struct lockdep_map { }; + + #define lockdep_depth(tsk) (0) + ++#define lockdep_is_held(lock) (1) + #define lockdep_is_held_type(l, r) (1) + + #define lockdep_assert_held(l) do { (void)(l); } while (0) +diff --git a/include/linux/mm.h b/include/linux/mm.h +index dc7b87310c10..40e450bbf00f 100644 +--- a/include/linux/mm.h ++++ b/include/linux/mm.h +@@ -1684,6 +1684,28 @@ static inline void unmap_shared_mapping_range(struct address_space *mapping, + unmap_mapping_range(mapping, holebegin, holelen, 0); + } + ++extern void vma_do_file_update_time(struct vm_area_struct *, const char[], int); ++extern struct file *vma_do_pr_or_file(struct vm_area_struct *, const char[], ++ int); ++extern void vma_do_get_file(struct vm_area_struct *, const char[], int); ++extern void vma_do_fput(struct vm_area_struct *, const char[], int); ++ ++#define vma_file_update_time(vma) vma_do_file_update_time(vma, __func__, \ ++ __LINE__) ++#define vma_pr_or_file(vma) vma_do_pr_or_file(vma, __func__, \ ++ __LINE__) ++#define vma_get_file(vma) vma_do_get_file(vma, __func__, __LINE__) ++#define vma_fput(vma) vma_do_fput(vma, __func__, __LINE__) ++ ++#ifndef CONFIG_MMU ++extern struct file *vmr_do_pr_or_file(struct vm_region *, const char[], int); ++extern void vmr_do_fput(struct vm_region *, const char[], int); ++ ++#define vmr_pr_or_file(region) vmr_do_pr_or_file(region, __func__, \ ++ __LINE__) ++#define vmr_fput(region) vmr_do_fput(region, __func__, __LINE__) ++#endif /* !CONFIG_MMU */ ++ + extern int access_process_vm(struct task_struct *tsk, unsigned long addr, + void *buf, int len, unsigned int gup_flags); + extern int access_remote_vm(struct mm_struct *mm, unsigned long addr, +diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h +index 64ede5f150dc..1c899fd6bda4 100644 +--- a/include/linux/mm_types.h ++++ b/include/linux/mm_types.h +@@ -276,6 +276,7 @@ struct vm_region { + unsigned long vm_top; /* region allocated to here */ + unsigned long vm_pgoff; /* the offset in vm_file corresponding to vm_start */ + struct file *vm_file; /* the backing file or NULL */ ++ struct file *vm_prfile; /* the virtual backing file or NULL */ + + int vm_usage; /* region usage count (access under nommu_region_sem) */ + bool vm_icache_flushed : 1; /* true if the icache has been flushed for +@@ -355,6 +356,7 @@ struct vm_area_struct { + unsigned long vm_pgoff; /* Offset (within vm_file) in PAGE_SIZE + units */ + struct file * vm_file; /* File we map to (can be NULL). */ ++ struct file *vm_prfile; /* shadow of vm_file */ + void * vm_private_data; /* was vm_pte (shared mem) */ + + #ifdef CONFIG_SWAP +diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h +index 8f882f5881e8..6b9808f09843 100644 +--- a/include/linux/mnt_namespace.h ++++ b/include/linux/mnt_namespace.h +@@ -7,12 +7,15 @@ struct mnt_namespace; + struct fs_struct; + struct user_namespace; + struct ns_common; ++struct vfsmount; + + extern struct mnt_namespace *copy_mnt_ns(unsigned long, struct mnt_namespace *, + struct user_namespace *, struct fs_struct *); + extern void put_mnt_ns(struct mnt_namespace *ns); + extern struct ns_common *from_mnt_ns(struct mnt_namespace *); + ++extern int is_current_mnt_ns(struct vfsmount *mnt); ++ + extern const struct file_operations proc_mounts_operations; + extern const struct file_operations proc_mountinfo_operations; + extern const struct file_operations proc_mountstats_operations; +diff --git a/include/linux/splice.h b/include/linux/splice.h +index 5c47013f708e..fef6c59ed92a 100644 +--- a/include/linux/splice.h ++++ b/include/linux/splice.h +@@ -93,4 +93,10 @@ extern void splice_shrink_spd(struct splice_pipe_desc *); + + extern const struct pipe_buf_operations page_cache_pipe_buf_ops; + extern const struct pipe_buf_operations default_pipe_buf_ops; ++ ++extern long do_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags); ++extern long do_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags); + #endif +diff --git a/include/uapi/linux/aufs_type.h b/include/uapi/linux/aufs_type.h +new file mode 100644 +index 000000000000..71501ea96e0b +--- /dev/null ++++ b/include/uapi/linux/aufs_type.h +@@ -0,0 +1,439 @@ ++/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ ++/* ++ * Copyright (C) 2005-2020 Junjiro R. Okajima ++ */ ++ ++#ifndef __AUFS_TYPE_H__ ++#define __AUFS_TYPE_H__ ++ ++#define AUFS_NAME "aufs" ++ ++#ifdef __KERNEL__ ++/* ++ * define it before including all other headers. ++ * sched.h may use pr_* macros before defining "current", so define the ++ * no-current version first, and re-define later. ++ */ ++#define pr_fmt(fmt) AUFS_NAME " %s:%d: " fmt, __func__, __LINE__ ++#include ++#undef pr_fmt ++#define pr_fmt(fmt) \ ++ AUFS_NAME " %s:%d:%.*s[%d]: " fmt, __func__, __LINE__, \ ++ (int)sizeof(current->comm), current->comm, current->pid ++#include ++#else ++#include ++#include ++#include ++#endif /* __KERNEL__ */ ++ ++#define AUFS_VERSION "5.7" ++ ++/* todo? move this to linux-2.6.19/include/magic.h */ ++#define AUFS_SUPER_MAGIC ('a' << 24 | 'u' << 16 | 'f' << 8 | 's') ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef __KERNEL__ ++#ifdef CONFIG_AUFS_BRANCH_MAX_127 ++typedef int8_t aufs_bindex_t; ++#define AUFS_BRANCH_MAX 127 ++#else ++typedef int16_t aufs_bindex_t; ++#ifdef CONFIG_AUFS_BRANCH_MAX_511 ++#define AUFS_BRANCH_MAX 511 ++#elif defined(CONFIG_AUFS_BRANCH_MAX_1023) ++#define AUFS_BRANCH_MAX 1023 ++#elif defined(CONFIG_AUFS_BRANCH_MAX_32767) ++#define AUFS_BRANCH_MAX 32767 ++#endif ++#endif ++ ++#ifndef AUFS_BRANCH_MAX ++#error unknown CONFIG_AUFS_BRANCH_MAX value ++#endif ++#endif /* __KERNEL__ */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define AUFS_FSTYPE AUFS_NAME ++ ++#define AUFS_ROOT_INO 2 ++#define AUFS_FIRST_INO 11 ++ ++#define AUFS_WH_PFX ".wh." ++#define AUFS_WH_PFX_LEN ((int)sizeof(AUFS_WH_PFX) - 1) ++#define AUFS_WH_TMP_LEN 4 ++/* a limit for rmdir/rename a dir and copyup */ ++#define AUFS_MAX_NAMELEN (NAME_MAX \ ++ - AUFS_WH_PFX_LEN * 2 /* doubly whiteouted */\ ++ - 1 /* dot */\ ++ - AUFS_WH_TMP_LEN) /* hex */ ++#define AUFS_XINO_FNAME "." AUFS_NAME ".xino" ++#define AUFS_XINO_DEFPATH "/tmp/" AUFS_XINO_FNAME ++#define AUFS_XINO_DEF_SEC 30 /* seconds */ ++#define AUFS_XINO_DEF_TRUNC 45 /* percentage */ ++#define AUFS_DIRWH_DEF 3 ++#define AUFS_RDCACHE_DEF 10 /* seconds */ ++#define AUFS_RDCACHE_MAX 3600 /* seconds */ ++#define AUFS_RDBLK_DEF 512 /* bytes */ ++#define AUFS_RDHASH_DEF 32 ++#define AUFS_WKQ_NAME AUFS_NAME "d" ++#define AUFS_MFS_DEF_SEC 30 /* seconds */ ++#define AUFS_MFS_MAX_SEC 3600 /* seconds */ ++#define AUFS_FHSM_CACHE_DEF_SEC 30 /* seconds */ ++#define AUFS_PLINK_WARN 50 /* number of plinks in a single bucket */ ++ ++/* pseudo-link maintenace under /proc */ ++#define AUFS_PLINK_MAINT_NAME "plink_maint" ++#define AUFS_PLINK_MAINT_DIR "fs/" AUFS_NAME ++#define AUFS_PLINK_MAINT_PATH AUFS_PLINK_MAINT_DIR "/" AUFS_PLINK_MAINT_NAME ++ ++/* dirren, renamed dir */ ++#define AUFS_DR_INFO_PFX AUFS_WH_PFX ".dr." ++#define AUFS_DR_BRHINO_NAME AUFS_WH_PFX "hino" ++/* whiteouted doubly */ ++#define AUFS_WH_DR_INFO_PFX AUFS_WH_PFX AUFS_DR_INFO_PFX ++#define AUFS_WH_DR_BRHINO AUFS_WH_PFX AUFS_DR_BRHINO_NAME ++ ++#define AUFS_DIROPQ_NAME AUFS_WH_PFX ".opq" /* whiteouted doubly */ ++#define AUFS_WH_DIROPQ AUFS_WH_PFX AUFS_DIROPQ_NAME ++ ++#define AUFS_BASE_NAME AUFS_WH_PFX AUFS_NAME ++#define AUFS_PLINKDIR_NAME AUFS_WH_PFX "plnk" ++#define AUFS_ORPHDIR_NAME AUFS_WH_PFX "orph" ++ ++/* doubly whiteouted */ ++#define AUFS_WH_BASE AUFS_WH_PFX AUFS_BASE_NAME ++#define AUFS_WH_PLINKDIR AUFS_WH_PFX AUFS_PLINKDIR_NAME ++#define AUFS_WH_ORPHDIR AUFS_WH_PFX AUFS_ORPHDIR_NAME ++ ++/* branch permissions and attributes */ ++#define AUFS_BRPERM_RW "rw" ++#define AUFS_BRPERM_RO "ro" ++#define AUFS_BRPERM_RR "rr" ++#define AUFS_BRATTR_COO_REG "coo_reg" ++#define AUFS_BRATTR_COO_ALL "coo_all" ++#define AUFS_BRATTR_FHSM "fhsm" ++#define AUFS_BRATTR_UNPIN "unpin" ++#define AUFS_BRATTR_ICEX "icex" ++#define AUFS_BRATTR_ICEX_SEC "icexsec" ++#define AUFS_BRATTR_ICEX_SYS "icexsys" ++#define AUFS_BRATTR_ICEX_TR "icextr" ++#define AUFS_BRATTR_ICEX_USR "icexusr" ++#define AUFS_BRATTR_ICEX_OTH "icexoth" ++#define AUFS_BRRATTR_WH "wh" ++#define AUFS_BRWATTR_NLWH "nolwh" ++#define AUFS_BRWATTR_MOO "moo" ++ ++#define AuBrPerm_RW 1 /* writable, hardlinkable wh */ ++#define AuBrPerm_RO (1 << 1) /* readonly */ ++#define AuBrPerm_RR (1 << 2) /* natively readonly */ ++#define AuBrPerm_Mask (AuBrPerm_RW | AuBrPerm_RO | AuBrPerm_RR) ++ ++#define AuBrAttr_COO_REG (1 << 3) /* copy-up on open */ ++#define AuBrAttr_COO_ALL (1 << 4) ++#define AuBrAttr_COO_Mask (AuBrAttr_COO_REG | AuBrAttr_COO_ALL) ++ ++#define AuBrAttr_FHSM (1 << 5) /* file-based hsm */ ++#define AuBrAttr_UNPIN (1 << 6) /* rename-able top dir of ++ branch. meaningless since ++ linux-3.18-rc1 */ ++ ++/* ignore error in copying XATTR */ ++#define AuBrAttr_ICEX_SEC (1 << 7) ++#define AuBrAttr_ICEX_SYS (1 << 8) ++#define AuBrAttr_ICEX_TR (1 << 9) ++#define AuBrAttr_ICEX_USR (1 << 10) ++#define AuBrAttr_ICEX_OTH (1 << 11) ++#define AuBrAttr_ICEX (AuBrAttr_ICEX_SEC \ ++ | AuBrAttr_ICEX_SYS \ ++ | AuBrAttr_ICEX_TR \ ++ | AuBrAttr_ICEX_USR \ ++ | AuBrAttr_ICEX_OTH) ++ ++#define AuBrRAttr_WH (1 << 12) /* whiteout-able */ ++#define AuBrRAttr_Mask AuBrRAttr_WH ++ ++#define AuBrWAttr_NoLinkWH (1 << 13) /* un-hardlinkable whiteouts */ ++#define AuBrWAttr_MOO (1 << 14) /* move-up on open */ ++#define AuBrWAttr_Mask (AuBrWAttr_NoLinkWH | AuBrWAttr_MOO) ++ ++#define AuBrAttr_CMOO_Mask (AuBrAttr_COO_Mask | AuBrWAttr_MOO) ++ ++/* #warning test userspace */ ++#ifdef __KERNEL__ ++#ifndef CONFIG_AUFS_FHSM ++#undef AuBrAttr_FHSM ++#define AuBrAttr_FHSM 0 ++#endif ++#ifndef CONFIG_AUFS_XATTR ++#undef AuBrAttr_ICEX ++#define AuBrAttr_ICEX 0 ++#undef AuBrAttr_ICEX_SEC ++#define AuBrAttr_ICEX_SEC 0 ++#undef AuBrAttr_ICEX_SYS ++#define AuBrAttr_ICEX_SYS 0 ++#undef AuBrAttr_ICEX_TR ++#define AuBrAttr_ICEX_TR 0 ++#undef AuBrAttr_ICEX_USR ++#define AuBrAttr_ICEX_USR 0 ++#undef AuBrAttr_ICEX_OTH ++#define AuBrAttr_ICEX_OTH 0 ++#endif ++#endif ++ ++/* the longest combination */ ++/* AUFS_BRATTR_ICEX and AUFS_BRATTR_ICEX_TR don't affect here */ ++#define AuBrPermStrSz sizeof(AUFS_BRPERM_RW \ ++ "+" AUFS_BRATTR_COO_REG \ ++ "+" AUFS_BRATTR_FHSM \ ++ "+" AUFS_BRATTR_UNPIN \ ++ "+" AUFS_BRATTR_ICEX_SEC \ ++ "+" AUFS_BRATTR_ICEX_SYS \ ++ "+" AUFS_BRATTR_ICEX_USR \ ++ "+" AUFS_BRATTR_ICEX_OTH \ ++ "+" AUFS_BRWATTR_NLWH) ++ ++typedef struct { ++ char a[AuBrPermStrSz]; ++} au_br_perm_str_t; ++ ++static inline int au_br_writable(int brperm) ++{ ++ return brperm & AuBrPerm_RW; ++} ++ ++static inline int au_br_whable(int brperm) ++{ ++ return brperm & (AuBrPerm_RW | AuBrRAttr_WH); ++} ++ ++static inline int au_br_wh_linkable(int brperm) ++{ ++ return !(brperm & AuBrWAttr_NoLinkWH); ++} ++ ++static inline int au_br_cmoo(int brperm) ++{ ++ return brperm & AuBrAttr_CMOO_Mask; ++} ++ ++static inline int au_br_fhsm(int brperm) ++{ ++ return brperm & AuBrAttr_FHSM; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ioctl */ ++enum { ++ /* readdir in userspace */ ++ AuCtl_RDU, ++ AuCtl_RDU_INO, ++ ++ AuCtl_WBR_FD, /* pathconf wrapper */ ++ AuCtl_IBUSY, /* busy inode */ ++ AuCtl_MVDOWN, /* move-down */ ++ AuCtl_BR, /* info about branches */ ++ AuCtl_FHSM_FD /* connection for fhsm */ ++}; ++ ++/* borrowed from linux/include/linux/kernel.h */ ++#ifndef ALIGN ++#ifdef _GNU_SOURCE ++#define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a)-1) ++#else ++#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1)) ++#endif ++#define __ALIGN_MASK(x, mask) (((x)+(mask))&~(mask)) ++#endif ++ ++/* borrowed from linux/include/linux/compiler-gcc3.h */ ++#ifndef __aligned ++#define __aligned(x) __attribute__((aligned(x))) ++#endif ++ ++#ifdef __KERNEL__ ++#ifndef __packed ++#define __packed __attribute__((packed)) ++#endif ++#endif ++ ++struct au_rdu_cookie { ++ uint64_t h_pos; ++ int16_t bindex; ++ uint8_t flags; ++ uint8_t pad; ++ uint32_t generation; ++} __aligned(8); ++ ++struct au_rdu_ent { ++ uint64_t ino; ++ int16_t bindex; ++ uint8_t type; ++ uint8_t nlen; ++ uint8_t wh; ++ char name[]; ++} __aligned(8); ++ ++static inline int au_rdu_len(int nlen) ++{ ++ /* include the terminating NULL */ ++ return ALIGN(sizeof(struct au_rdu_ent) + nlen + 1, ++ sizeof(uint64_t)); ++} ++ ++union au_rdu_ent_ul { ++ struct au_rdu_ent __user *e; ++ uint64_t ul; ++}; ++ ++enum { ++ AufsCtlRduV_SZ, ++ AufsCtlRduV_End ++}; ++ ++struct aufs_rdu { ++ /* input */ ++ union { ++ uint64_t sz; /* AuCtl_RDU */ ++ uint64_t nent; /* AuCtl_RDU_INO */ ++ }; ++ union au_rdu_ent_ul ent; ++ uint16_t verify[AufsCtlRduV_End]; ++ ++ /* input/output */ ++ uint32_t blk; ++ ++ /* output */ ++ union au_rdu_ent_ul tail; ++ /* number of entries which were added in a single call */ ++ uint64_t rent; ++ uint8_t full; ++ uint8_t shwh; ++ ++ struct au_rdu_cookie cookie; ++} __aligned(8); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dirren. the branch is identified by the filename who contains this */ ++struct au_drinfo { ++ uint64_t ino; ++ union { ++ uint8_t oldnamelen; ++ uint64_t _padding; ++ }; ++ uint8_t oldname[]; ++} __aligned(8); ++ ++struct au_drinfo_fdata { ++ uint32_t magic; ++ struct au_drinfo drinfo; ++} __aligned(8); ++ ++#define AUFS_DRINFO_MAGIC_V1 ('a' << 24 | 'd' << 16 | 'r' << 8 | 0x01) ++/* future */ ++#define AUFS_DRINFO_MAGIC_V2 ('a' << 24 | 'd' << 16 | 'r' << 8 | 0x02) ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct aufs_wbr_fd { ++ uint32_t oflags; ++ int16_t brid; ++} __aligned(8); ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct aufs_ibusy { ++ uint64_t ino, h_ino; ++ int16_t bindex; ++} __aligned(8); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* error code for move-down */ ++/* the actual message strings are implemented in aufs-util.git */ ++enum { ++ EAU_MVDOWN_OPAQUE = 1, ++ EAU_MVDOWN_WHITEOUT, ++ EAU_MVDOWN_UPPER, ++ EAU_MVDOWN_BOTTOM, ++ EAU_MVDOWN_NOUPPER, ++ EAU_MVDOWN_NOLOWERBR, ++ EAU_Last ++}; ++ ++/* flags for move-down */ ++#define AUFS_MVDOWN_DMSG 1 ++#define AUFS_MVDOWN_OWLOWER (1 << 1) /* overwrite lower */ ++#define AUFS_MVDOWN_KUPPER (1 << 2) /* keep upper */ ++#define AUFS_MVDOWN_ROLOWER (1 << 3) /* do even if lower is RO */ ++#define AUFS_MVDOWN_ROLOWER_R (1 << 4) /* did on lower RO */ ++#define AUFS_MVDOWN_ROUPPER (1 << 5) /* do even if upper is RO */ ++#define AUFS_MVDOWN_ROUPPER_R (1 << 6) /* did on upper RO */ ++#define AUFS_MVDOWN_BRID_UPPER (1 << 7) /* upper brid */ ++#define AUFS_MVDOWN_BRID_LOWER (1 << 8) /* lower brid */ ++#define AUFS_MVDOWN_FHSM_LOWER (1 << 9) /* find fhsm attr for lower */ ++#define AUFS_MVDOWN_STFS (1 << 10) /* req. stfs */ ++#define AUFS_MVDOWN_STFS_FAILED (1 << 11) /* output: stfs is unusable */ ++#define AUFS_MVDOWN_BOTTOM (1 << 12) /* output: no more lowers */ ++ ++/* index for move-down */ ++enum { ++ AUFS_MVDOWN_UPPER, ++ AUFS_MVDOWN_LOWER, ++ AUFS_MVDOWN_NARRAY ++}; ++ ++/* ++ * additional info of move-down ++ * number of free blocks and inodes. ++ * subset of struct kstatfs, but smaller and always 64bit. ++ */ ++struct aufs_stfs { ++ uint64_t f_blocks; ++ uint64_t f_bavail; ++ uint64_t f_files; ++ uint64_t f_ffree; ++}; ++ ++struct aufs_stbr { ++ int16_t brid; /* optional input */ ++ int16_t bindex; /* output */ ++ struct aufs_stfs stfs; /* output when AUFS_MVDOWN_STFS set */ ++} __aligned(8); ++ ++struct aufs_mvdown { ++ uint32_t flags; /* input/output */ ++ struct aufs_stbr stbr[AUFS_MVDOWN_NARRAY]; /* input/output */ ++ int8_t au_errno; /* output */ ++} __aligned(8); ++ ++/* ---------------------------------------------------------------------- */ ++ ++union aufs_brinfo { ++ /* PATH_MAX may differ between kernel-space and user-space */ ++ char _spacer[4096]; ++ struct { ++ int16_t id; ++ int perm; ++ char path[]; ++ }; ++} __aligned(8); ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define AuCtlType 'A' ++#define AUFS_CTL_RDU _IOWR(AuCtlType, AuCtl_RDU, struct aufs_rdu) ++#define AUFS_CTL_RDU_INO _IOWR(AuCtlType, AuCtl_RDU_INO, struct aufs_rdu) ++#define AUFS_CTL_WBR_FD _IOW(AuCtlType, AuCtl_WBR_FD, \ ++ struct aufs_wbr_fd) ++#define AUFS_CTL_IBUSY _IOWR(AuCtlType, AuCtl_IBUSY, struct aufs_ibusy) ++#define AUFS_CTL_MVDOWN _IOWR(AuCtlType, AuCtl_MVDOWN, \ ++ struct aufs_mvdown) ++#define AUFS_CTL_BRINFO _IOW(AuCtlType, AuCtl_BR, union aufs_brinfo) ++#define AUFS_CTL_FHSM_FD _IOW(AuCtlType, AuCtl_FHSM_FD, int) ++ ++#endif /* __AUFS_TYPE_H__ */ +diff --git a/kernel/fork.c b/kernel/fork.c +index efc5493203ae..ba1174fb5d91 100644 +--- a/kernel/fork.c ++++ b/kernel/fork.c +@@ -570,7 +570,7 @@ static __latent_entropy int dup_mmap(struct mm_struct *mm, + struct inode *inode = file_inode(file); + struct address_space *mapping = file->f_mapping; + +- get_file(file); ++ vma_get_file(tmp); + if (tmp->vm_flags & VM_DENYWRITE) + atomic_dec(&inode->i_writecount); + i_mmap_lock_write(mapping); +diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c +index 29a8de4c50b9..1d54603f1f56 100644 +--- a/kernel/locking/lockdep.c ++++ b/kernel/locking/lockdep.c +@@ -169,7 +169,7 @@ static + struct lock_class lock_classes[MAX_LOCKDEP_KEYS]; + static DECLARE_BITMAP(lock_classes_in_use, MAX_LOCKDEP_KEYS); + +-static inline struct lock_class *hlock_class(struct held_lock *hlock) ++inline struct lock_class *lockdep_hlock_class(struct held_lock *hlock) + { + unsigned int class_idx = hlock->class_idx; + +@@ -190,6 +190,8 @@ static inline struct lock_class *hlock_class(struct held_lock *hlock) + */ + return lock_classes + class_idx; + } ++EXPORT_SYMBOL_GPL(lockdep_hlock_class); ++#define hlock_class(hlock) lockdep_hlock_class(hlock) + + #ifdef CONFIG_LOCK_STAT + static DEFINE_PER_CPU(struct lock_class_stats[MAX_LOCKDEP_KEYS], cpu_lock_stats); +diff --git a/kernel/task_work.c b/kernel/task_work.c +index 5c0848ca1287..87f09e627840 100644 +--- a/kernel/task_work.c ++++ b/kernel/task_work.c +@@ -138,3 +138,4 @@ void task_work_run(void) + } while (work); + } + } ++EXPORT_SYMBOL_GPL(task_work_run); +diff --git a/mm/Makefile b/mm/Makefile +index 6e9d46b2efc9..a432b5664d83 100644 +--- a/mm/Makefile ++++ b/mm/Makefile +@@ -52,7 +52,7 @@ obj-y := filemap.o mempool.o oom_kill.o fadvise.o \ + mm_init.o percpu.o slab_common.o \ + compaction.o vmacache.o \ + interval_tree.o list_lru.o workingset.o \ +- debug.o gup.o $(mmu-y) ++ prfile.o debug.o gup.o $(mmu-y) + + # Give 'page_alloc' its own module-parameter namespace + page-alloc-y := page_alloc.o +diff --git a/mm/filemap.c b/mm/filemap.c +index 385759c4ce4b..570f4e1bc4d3 100644 +--- a/mm/filemap.c ++++ b/mm/filemap.c +@@ -2676,7 +2676,7 @@ vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf) + vm_fault_t ret = VM_FAULT_LOCKED; + + sb_start_pagefault(inode->i_sb); +- file_update_time(vmf->vma->vm_file); ++ vma_file_update_time(vmf->vma); + lock_page(page); + if (page->mapping != inode->i_mapping) { + unlock_page(page); +diff --git a/mm/mmap.c b/mm/mmap.c +index 8c7ca737a19b..c4e2b1383925 100644 +--- a/mm/mmap.c ++++ b/mm/mmap.c +@@ -179,7 +179,7 @@ static struct vm_area_struct *remove_vma(struct vm_area_struct *vma) + if (vma->vm_ops && vma->vm_ops->close) + vma->vm_ops->close(vma); + if (vma->vm_file) +- fput(vma->vm_file); ++ vma_fput(vma); + mpol_put(vma_policy(vma)); + vm_area_free(vma); + return next; +@@ -910,7 +910,7 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start, + if (remove_next) { + if (file) { + uprobe_munmap(next, next->vm_start, next->vm_end); +- fput(file); ++ vma_fput(vma); + } + if (next->anon_vma) + anon_vma_merge(vma, next); +@@ -1831,8 +1831,8 @@ unsigned long mmap_region(struct file *file, unsigned long addr, + return addr; + + unmap_and_free_vma: ++ vma_fput(vma); + vma->vm_file = NULL; +- fput(file); + + /* Undo any partial mapping done by a device driver. */ + unmap_region(mm, vma, prev, vma->vm_start, vma->vm_end); +@@ -2694,7 +2694,7 @@ int __split_vma(struct mm_struct *mm, struct vm_area_struct *vma, + goto out_free_mpol; + + if (new->vm_file) +- get_file(new->vm_file); ++ vma_get_file(new); + + if (new->vm_ops && new->vm_ops->open) + new->vm_ops->open(new); +@@ -2713,7 +2713,7 @@ int __split_vma(struct mm_struct *mm, struct vm_area_struct *vma, + if (new->vm_ops && new->vm_ops->close) + new->vm_ops->close(new); + if (new->vm_file) +- fput(new->vm_file); ++ vma_fput(new); + unlink_anon_vmas(new); + out_free_mpol: + mpol_put(vma_policy(new)); +@@ -2906,7 +2906,7 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size, + struct vm_area_struct *vma; + unsigned long populate = 0; + unsigned long ret = -EINVAL; +- struct file *file; ++ struct file *file, *prfile; + + pr_warn_once("%s (%d) uses deprecated remap_file_pages() syscall. See Documentation/vm/remap_file_pages.rst.\n", + current->comm, current->pid); +@@ -2981,10 +2981,27 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size, + } + } + +- file = get_file(vma->vm_file); ++ vma_get_file(vma); ++ file = vma->vm_file; ++ prfile = vma->vm_prfile; + ret = do_mmap_pgoff(vma->vm_file, start, size, + prot, flags, pgoff, &populate, NULL); ++ if (!IS_ERR_VALUE(ret) && file && prfile) { ++ struct vm_area_struct *new_vma; ++ ++ new_vma = find_vma(mm, ret); ++ if (!new_vma->vm_prfile) ++ new_vma->vm_prfile = prfile; ++ if (new_vma != vma) ++ get_file(prfile); ++ } ++ /* ++ * two fput()s instead of vma_fput(vma), ++ * coz vma may not be available anymore. ++ */ + fput(file); ++ if (prfile) ++ fput(prfile); + out: + mmap_write_unlock(mm); + if (populate) +@@ -3275,7 +3292,7 @@ struct vm_area_struct *copy_vma(struct vm_area_struct **vmap, + if (anon_vma_clone(new_vma, vma)) + goto out_free_mempol; + if (new_vma->vm_file) +- get_file(new_vma->vm_file); ++ vma_get_file(new_vma); + if (new_vma->vm_ops && new_vma->vm_ops->open) + new_vma->vm_ops->open(new_vma); + vma_link(mm, new_vma, prev, rb_link, rb_parent); +diff --git a/mm/nommu.c b/mm/nommu.c +index f32a69095d50..26cd21666185 100644 +--- a/mm/nommu.c ++++ b/mm/nommu.c +@@ -540,7 +540,7 @@ static void __put_nommu_region(struct vm_region *region) + up_write(&nommu_region_sem); + + if (region->vm_file) +- fput(region->vm_file); ++ vmr_fput(region); + + /* IO memory and memory shared directly out of the pagecache + * from ramfs/tmpfs mustn't be released here */ +@@ -672,7 +672,7 @@ static void delete_vma(struct mm_struct *mm, struct vm_area_struct *vma) + if (vma->vm_ops && vma->vm_ops->close) + vma->vm_ops->close(vma); + if (vma->vm_file) +- fput(vma->vm_file); ++ vma_fput(vma); + put_nommu_region(vma->vm_region); + vm_area_free(vma); + } +@@ -1195,7 +1195,7 @@ unsigned long do_mmap(struct file *file, + goto error_just_free; + } + } +- fput(region->vm_file); ++ vmr_fput(region); + kmem_cache_free(vm_region_jar, region); + region = pregion; + result = start; +@@ -1272,10 +1272,10 @@ unsigned long do_mmap(struct file *file, + up_write(&nommu_region_sem); + error: + if (region->vm_file) +- fput(region->vm_file); ++ vmr_fput(region); + kmem_cache_free(vm_region_jar, region); + if (vma->vm_file) +- fput(vma->vm_file); ++ vma_fput(vma); + vm_area_free(vma); + return ret; + +diff --git a/mm/prfile.c b/mm/prfile.c +new file mode 100644 +index 000000000000..00d51187c325 +--- /dev/null ++++ b/mm/prfile.c +@@ -0,0 +1,86 @@ ++// SPDX-License-Identifier: GPL-2.0 ++/* ++ * Mainly for aufs which mmap(2) different file and wants to print different ++ * path in /proc/PID/maps. ++ * Call these functions via macros defined in linux/mm.h. ++ * ++ * See Documentation/filesystems/aufs/design/06mmap.txt ++ * ++ * Copyright (c) 2014-2020 Junjro R. Okajima ++ * Copyright (c) 2014 Ian Campbell ++ */ ++ ++#include ++#include ++#include ++ ++/* #define PRFILE_TRACE */ ++static inline void prfile_trace(struct file *f, struct file *pr, ++ const char func[], int line, const char func2[]) ++{ ++#ifdef PRFILE_TRACE ++ if (pr) ++ pr_info("%s:%d: %s, %pD2\n", func, line, func2, f); ++#endif ++} ++ ++void vma_do_file_update_time(struct vm_area_struct *vma, const char func[], ++ int line) ++{ ++ struct file *f = vma->vm_file, *pr = vma->vm_prfile; ++ ++ prfile_trace(f, pr, func, line, __func__); ++ file_update_time(f); ++ if (f && pr) ++ file_update_time(pr); ++} ++ ++struct file *vma_do_pr_or_file(struct vm_area_struct *vma, const char func[], ++ int line) ++{ ++ struct file *f = vma->vm_file, *pr = vma->vm_prfile; ++ ++ prfile_trace(f, pr, func, line, __func__); ++ return (f && pr) ? pr : f; ++} ++ ++void vma_do_get_file(struct vm_area_struct *vma, const char func[], int line) ++{ ++ struct file *f = vma->vm_file, *pr = vma->vm_prfile; ++ ++ prfile_trace(f, pr, func, line, __func__); ++ get_file(f); ++ if (f && pr) ++ get_file(pr); ++} ++ ++void vma_do_fput(struct vm_area_struct *vma, const char func[], int line) ++{ ++ struct file *f = vma->vm_file, *pr = vma->vm_prfile; ++ ++ prfile_trace(f, pr, func, line, __func__); ++ fput(f); ++ if (f && pr) ++ fput(pr); ++} ++ ++#ifndef CONFIG_MMU ++struct file *vmr_do_pr_or_file(struct vm_region *region, const char func[], ++ int line) ++{ ++ struct file *f = region->vm_file, *pr = region->vm_prfile; ++ ++ prfile_trace(f, pr, func, line, __func__); ++ return (f && pr) ? pr : f; ++} ++ ++void vmr_do_fput(struct vm_region *region, const char func[], int line) ++{ ++ struct file *f = region->vm_file, *pr = region->vm_prfile; ++ ++ prfile_trace(f, pr, func, line, __func__); ++ fput(f); ++ if (f && pr) ++ fput(pr); ++} ++#endif /* !CONFIG_MMU */ +diff --git a/security/security.c b/security/security.c +index 70a7ad357bc6..d55b72977544 100644 +--- a/security/security.c ++++ b/security/security.c +@@ -1092,6 +1092,7 @@ int security_path_rmdir(const struct path *dir, struct dentry *dentry) + return 0; + return call_int_hook(path_rmdir, 0, dir, dentry); + } ++EXPORT_SYMBOL_GPL(security_path_rmdir); + + int security_path_unlink(const struct path *dir, struct dentry *dentry) + { +@@ -1108,6 +1109,7 @@ int security_path_symlink(const struct path *dir, struct dentry *dentry, + return 0; + return call_int_hook(path_symlink, 0, dir, dentry, old_name); + } ++EXPORT_SYMBOL_GPL(security_path_symlink); + + int security_path_link(struct dentry *old_dentry, const struct path *new_dir, + struct dentry *new_dentry) +@@ -1116,6 +1118,7 @@ int security_path_link(struct dentry *old_dentry, const struct path *new_dir, + return 0; + return call_int_hook(path_link, 0, old_dentry, new_dir, new_dentry); + } ++EXPORT_SYMBOL_GPL(security_path_link); + + int security_path_rename(const struct path *old_dir, struct dentry *old_dentry, + const struct path *new_dir, struct dentry *new_dentry, +@@ -1143,6 +1146,7 @@ int security_path_truncate(const struct path *path) + return 0; + return call_int_hook(path_truncate, 0, path); + } ++EXPORT_SYMBOL_GPL(security_path_truncate); + + int security_path_chmod(const struct path *path, umode_t mode) + { +@@ -1150,6 +1154,7 @@ int security_path_chmod(const struct path *path, umode_t mode) + return 0; + return call_int_hook(path_chmod, 0, path, mode); + } ++EXPORT_SYMBOL_GPL(security_path_chmod); + + int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid) + { +@@ -1157,6 +1162,7 @@ int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid) + return 0; + return call_int_hook(path_chown, 0, path, uid, gid); + } ++EXPORT_SYMBOL_GPL(security_path_chown); + + int security_path_chroot(const struct path *path) + { +@@ -1257,6 +1263,7 @@ int security_inode_permission(struct inode *inode, int mask) + return 0; + return call_int_hook(inode_permission, 0, inode, mask); + } ++EXPORT_SYMBOL_GPL(security_inode_permission); + + int security_inode_setattr(struct dentry *dentry, struct iattr *attr) + { +@@ -1449,6 +1456,7 @@ int security_file_permission(struct file *file, int mask) + + return fsnotify_perm(file, mask); + } ++EXPORT_SYMBOL_GPL(security_file_permission); + + int security_file_alloc(struct file *file) + { diff --git a/kernel/tools/cpupowertools/pspec.xml b/kernel/tools/cpupowertools/pspec.xml index 2f92b343..85f5e529 100644 --- a/kernel/tools/cpupowertools/pspec.xml +++ b/kernel/tools/cpupowertools/pspec.xml @@ -12,17 +12,15 @@ app:console

CPU power management tools cpupowertools contains utilities to manage power management and frequency scaling policies of modern CPUs. - https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.7.tar.gz + https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.8.tar.gz pciutils-devel - patches/linux/patch-5.7.14.xz + patches/linux/patch-5.8.8.xz - patches/mageia/fs-aufs-5.6.patch - patches/mageia/fs-aufs-5.6-modular.patch - patches/mageia/fs-aufs-5.6-fix.patch + patches/mageia/aufs5.patch patches/mageia/CVE-2019-12379.patch @@ -51,6 +49,13 @@ + + 2020-09-10 + 5.8.8 + Version bump + Mustafa Cinasal + muscnsl@gmail.com + 2020-08-07 5.7.14