omap3-pandora-kernel2: update
[openpandora.oe.git] / recipes / linux / omap3-pandora-kernel / aufs2 / 0007-AUFS2-Add-latest-AUFS2-in-tree-code-for-2.6.27.patch
1 From 4fafa8e8eedf21cf9aeed56f2b193110696154e2 Mon Sep 17 00:00:00 2001
2 From: David-John Willis <John.Willis@Distant-earth.com>
3 Date: Mon, 21 Dec 2009 21:36:25 +0000
4 Subject: [PATCH 7/7] AUFS2: Add latest AUFS2 in-tree code for 2.6.27.
5
6 ---
7  Documentation/ABI/testing/debugfs-aufs             |   40 +
8  Documentation/ABI/testing/sysfs-aufs               |   25 +
9  Documentation/filesystems/aufs/README              |  347 +++++
10  Documentation/filesystems/aufs/design/01intro.txt  |  137 ++
11  Documentation/filesystems/aufs/design/02struct.txt |  218 +++
12  Documentation/filesystems/aufs/design/03lookup.txt |  104 ++
13  Documentation/filesystems/aufs/design/04branch.txt |   76 +
14  .../filesystems/aufs/design/05wbr_policy.txt       |   65 +
15  .../filesystems/aufs/design/06fmode_exec.txt       |   33 +
16  Documentation/filesystems/aufs/design/07mmap.txt   |   53 +
17  Documentation/filesystems/aufs/design/08export.txt |   59 +
18  Documentation/filesystems/aufs/design/09shwh.txt   |   53 +
19  Documentation/filesystems/aufs/design/99plan.txt   |   96 ++
20  fs/Kconfig                                         |    2 +
21  fs/Makefile                                        |    1 +
22  fs/aufs/Kconfig                                    |  136 ++
23  fs/aufs/Makefile                                   |   23 +
24  fs/aufs/aufs.h                                     |   59 +
25  fs/aufs/branch.c                                   |  978 ++++++++++++
26  fs/aufs/branch.h                                   |  219 +++
27  fs/aufs/cpup.c                                     | 1048 +++++++++++++
28  fs/aufs/cpup.h                                     |   81 +
29  fs/aufs/dbgaufs.c                                  |  331 +++++
30  fs/aufs/dbgaufs.h                                  |   52 +
31  fs/aufs/dcsub.c                                    |  223 +++
32  fs/aufs/dcsub.h                                    |   54 +
33  fs/aufs/debug.c                                    |  431 ++++++
34  fs/aufs/debug.h                                    |  232 +++
35  fs/aufs/dentry.c                                   |  875 +++++++++++
36  fs/aufs/dentry.h                                   |  228 +++
37  fs/aufs/dinfo.c                                    |  367 +++++
38  fs/aufs/dir.c                                      |  579 ++++++++
39  fs/aufs/dir.h                                      |  127 ++
40  fs/aufs/export.c                                   |  745 ++++++++++
41  fs/aufs/f_op.c                                     |  810 ++++++++++
42  fs/aufs/f_op_sp.c                                  |  290 ++++
43  fs/aufs/file.c                                     |  620 ++++++++
44  fs/aufs/file.h                                     |  187 +++
45  fs/aufs/finfo.c                                    |  131 ++
46  fs/aufs/fstype.h                                   |  434 ++++++
47  fs/aufs/hinotify.c                                 |  755 ++++++++++
48  fs/aufs/i_op.c                                     |  875 +++++++++++
49  fs/aufs/i_op_add.c                                 |  658 +++++++++
50  fs/aufs/i_op_del.c                                 |  470 ++++++
51  fs/aufs/i_op_ren.c                                 |  965 ++++++++++++
52  fs/aufs/iinfo.c                                    |  283 ++++
53  fs/aufs/inode.c                                    |  414 ++++++
54  fs/aufs/inode.h                                    |  474 ++++++
55  fs/aufs/ioctl.c                                    |  127 ++
56  fs/aufs/loop.c                                     |   55 +
57  fs/aufs/loop.h                                     |   43 +
58  fs/aufs/magic.mk                                   |   66 +
59  fs/aufs/module.c                                   |  173 +++
60  fs/aufs/module.h                                   |   78 +
61  fs/aufs/opts.c                                     | 1550 ++++++++++++++++++++
62  fs/aufs/opts.h                                     |  196 +++
63  fs/aufs/plink.c                                    |  429 ++++++
64  fs/aufs/rdu.c                                      |  333 +++++
65  fs/aufs/rwsem.h                                    |  186 +++
66  fs/aufs/sbinfo.c                                   |  211 +++
67  fs/aufs/spl.h                                      |   57 +
68  fs/aufs/super.c                                    |  874 +++++++++++
69  fs/aufs/super.h                                    |  361 +++++
70  fs/aufs/sysaufs.c                                  |  104 ++
71  fs/aufs/sysaufs.h                                  |  105 ++
72  fs/aufs/sysfs.c                                    |  210 +++
73  fs/aufs/sysrq.c                                    |  118 ++
74  fs/aufs/vdir.c                                     |  884 +++++++++++
75  fs/aufs/vfsub.c                                    |  660 +++++++++
76  fs/aufs/vfsub.h                                    |  145 ++
77  fs/aufs/wbr_policy.c                               |  641 ++++++++
78  fs/aufs/whout.c                                    | 1054 +++++++++++++
79  fs/aufs/whout.h                                    |   87 ++
80  fs/aufs/wkq.c                                      |  259 ++++
81  fs/aufs/wkq.h                                      |   82 +
82  fs/aufs/xino.c                                     | 1199 +++++++++++++++
83  fs/namei.c                                         |    4 +-
84  fs/splice.c                                        |   10 +-
85  include/linux/Kbuild                               |    1 +
86  include/linux/aufs_type.h                          |  195 +++
87  include/linux/namei.h                              |    3 +
88  include/linux/splice.h                             |    6 +
89  scripts/basic/hash                                 |  Bin 0 -> 6907 bytes
90  83 files changed, 25962 insertions(+), 7 deletions(-)
91  create mode 100644 Documentation/ABI/testing/debugfs-aufs
92  create mode 100644 Documentation/ABI/testing/sysfs-aufs
93  create mode 100644 Documentation/filesystems/aufs/README
94  create mode 100644 Documentation/filesystems/aufs/design/01intro.txt
95  create mode 100644 Documentation/filesystems/aufs/design/02struct.txt
96  create mode 100644 Documentation/filesystems/aufs/design/03lookup.txt
97  create mode 100644 Documentation/filesystems/aufs/design/04branch.txt
98  create mode 100644 Documentation/filesystems/aufs/design/05wbr_policy.txt
99  create mode 100644 Documentation/filesystems/aufs/design/06fmode_exec.txt
100  create mode 100644 Documentation/filesystems/aufs/design/07mmap.txt
101  create mode 100644 Documentation/filesystems/aufs/design/08export.txt
102  create mode 100644 Documentation/filesystems/aufs/design/09shwh.txt
103  create mode 100644 Documentation/filesystems/aufs/design/99plan.txt
104  create mode 100644 fs/aufs/Kconfig
105  create mode 100644 fs/aufs/Makefile
106  create mode 100644 fs/aufs/aufs.h
107  create mode 100644 fs/aufs/branch.c
108  create mode 100644 fs/aufs/branch.h
109  create mode 100644 fs/aufs/cpup.c
110  create mode 100644 fs/aufs/cpup.h
111  create mode 100644 fs/aufs/dbgaufs.c
112  create mode 100644 fs/aufs/dbgaufs.h
113  create mode 100644 fs/aufs/dcsub.c
114  create mode 100644 fs/aufs/dcsub.h
115  create mode 100644 fs/aufs/debug.c
116  create mode 100644 fs/aufs/debug.h
117  create mode 100644 fs/aufs/dentry.c
118  create mode 100644 fs/aufs/dentry.h
119  create mode 100644 fs/aufs/dinfo.c
120  create mode 100644 fs/aufs/dir.c
121  create mode 100644 fs/aufs/dir.h
122  create mode 100644 fs/aufs/export.c
123  create mode 100644 fs/aufs/f_op.c
124  create mode 100644 fs/aufs/f_op_sp.c
125  create mode 100644 fs/aufs/file.c
126  create mode 100644 fs/aufs/file.h
127  create mode 100644 fs/aufs/finfo.c
128  create mode 100644 fs/aufs/fstype.h
129  create mode 100644 fs/aufs/hinotify.c
130  create mode 100644 fs/aufs/i_op.c
131  create mode 100644 fs/aufs/i_op_add.c
132  create mode 100644 fs/aufs/i_op_del.c
133  create mode 100644 fs/aufs/i_op_ren.c
134  create mode 100644 fs/aufs/iinfo.c
135  create mode 100644 fs/aufs/inode.c
136  create mode 100644 fs/aufs/inode.h
137  create mode 100644 fs/aufs/ioctl.c
138  create mode 100644 fs/aufs/loop.c
139  create mode 100644 fs/aufs/loop.h
140  create mode 100644 fs/aufs/magic.mk
141  create mode 100644 fs/aufs/module.c
142  create mode 100644 fs/aufs/module.h
143  create mode 100644 fs/aufs/opts.c
144  create mode 100644 fs/aufs/opts.h
145  create mode 100644 fs/aufs/plink.c
146  create mode 100644 fs/aufs/rdu.c
147  create mode 100644 fs/aufs/rwsem.h
148  create mode 100644 fs/aufs/sbinfo.c
149  create mode 100644 fs/aufs/spl.h
150  create mode 100644 fs/aufs/super.c
151  create mode 100644 fs/aufs/super.h
152  create mode 100644 fs/aufs/sysaufs.c
153  create mode 100644 fs/aufs/sysaufs.h
154  create mode 100644 fs/aufs/sysfs.c
155  create mode 100644 fs/aufs/sysrq.c
156  create mode 100644 fs/aufs/vdir.c
157  create mode 100644 fs/aufs/vfsub.c
158  create mode 100644 fs/aufs/vfsub.h
159  create mode 100644 fs/aufs/wbr_policy.c
160  create mode 100644 fs/aufs/whout.c
161  create mode 100644 fs/aufs/whout.h
162  create mode 100644 fs/aufs/wkq.c
163  create mode 100644 fs/aufs/wkq.h
164  create mode 100644 fs/aufs/xino.c
165  create mode 100644 include/linux/aufs_type.h
166  create mode 100644 scripts/basic/hash
167
168 diff --git a/Documentation/ABI/testing/debugfs-aufs b/Documentation/ABI/testing/debugfs-aufs
169 new file mode 100644
170 index 0000000..4110b94
171 --- /dev/null
172 +++ b/Documentation/ABI/testing/debugfs-aufs
173 @@ -0,0 +1,40 @@
174 +What:          /debug/aufs/si_<id>/
175 +Date:          March 2009
176 +Contact:       J. R. Okajima <hooanon05@yahoo.co.jp>
177 +Description:
178 +               Under /debug/aufs, a directory named si_<id> is created
179 +               per aufs mount, where <id> is a unique id generated
180 +               internally.
181 +
182 +What:          /debug/aufs/si_<id>/xib
183 +Date:          March 2009
184 +Contact:       J. R. Okajima <hooanon05@yahoo.co.jp>
185 +Description:
186 +               It shows the consumed blocks by xib (External Inode Number
187 +               Bitmap), its block size and file size.
188 +               When the aufs mount option 'noxino' is specified, it
189 +               will be empty. About XINO files, see
190 +               Documentation/filesystems/aufs/aufs.5 in detail.
191 +
192 +What:          /debug/aufs/si_<id>/xino0, xino1 ... xinoN
193 +Date:          March 2009
194 +Contact:       J. R. Okajima <hooanon05@yahoo.co.jp>
195 +Description:
196 +               It shows the consumed blocks by xino (External Inode Number
197 +               Translation Table), its link count, block size and file
198 +               size.
199 +               When the aufs mount option 'noxino' is specified, it
200 +               will be empty. About XINO files, see
201 +               Documentation/filesystems/aufs/aufs.5 in detail.
202 +
203 +What:          /debug/aufs/si_<id>/xigen
204 +Date:          March 2009
205 +Contact:       J. R. Okajima <hooanon05@yahoo.co.jp>
206 +Description:
207 +               It shows the consumed blocks by xigen (External Inode
208 +               Generation Table), its block size and file size.
209 +               If CONFIG_AUFS_EXPORT is disabled, this entry will not
210 +               be created.
211 +               When the aufs mount option 'noxino' is specified, it
212 +               will be empty. About XINO files, see
213 +               Documentation/filesystems/aufs/aufs.5 in detail.
214 diff --git a/Documentation/ABI/testing/sysfs-aufs b/Documentation/ABI/testing/sysfs-aufs
215 new file mode 100644
216 index 0000000..ca49330
217 --- /dev/null
218 +++ b/Documentation/ABI/testing/sysfs-aufs
219 @@ -0,0 +1,25 @@
220 +What:          /sys/fs/aufs/si_<id>/
221 +Date:          March 2009
222 +Contact:       J. R. Okajima <hooanon05@yahoo.co.jp>
223 +Description:
224 +               Under /sys/fs/aufs, a directory named si_<id> is created
225 +               per aufs mount, where <id> is a unique id generated
226 +               internally.
227 +
228 +What:          /sys/fs/aufs/si_<id>/br0, br1 ... brN
229 +Date:          March 2009
230 +Contact:       J. R. Okajima <hooanon05@yahoo.co.jp>
231 +Description:
232 +               It shows the abolute path of a member directory (which
233 +               is called branch) in aufs, and its permission.
234 +
235 +What:          /sys/fs/aufs/si_<id>/xi_path
236 +Date:          March 2009
237 +Contact:       J. R. Okajima <hooanon05@yahoo.co.jp>
238 +Description:
239 +               It shows the abolute path of XINO (External Inode Number
240 +               Bitmap, Translation Table and Generation Table) file
241 +               even if it is the default path.
242 +               When the aufs mount option 'noxino' is specified, it
243 +               will be empty. About XINO files, see
244 +               Documentation/filesystems/aufs/aufs.5 in detail.
245 diff --git a/Documentation/filesystems/aufs/README b/Documentation/filesystems/aufs/README
246 new file mode 100644
247 index 0000000..2fbd3e6
248 --- /dev/null
249 +++ b/Documentation/filesystems/aufs/README
250 @@ -0,0 +1,347 @@
251 +
252 +Aufs2 -- advanced multi layered unification filesystem version 2
253 +http://aufs.sf.net
254 +Junjiro R. Okajima
255 +
256 +
257 +0. Introduction
258 +----------------------------------------
259 +In the early days, aufs was entirely re-designed and re-implemented
260 +Unionfs Version 1.x series. After many original ideas, approaches,
261 +improvements and implementations, it becomes totally different from
262 +Unionfs while keeping the basic features.
263 +Recently, Unionfs Version 2.x series begin taking some of the same
264 +approaches to aufs1's.
265 +Unionfs is being developed by Professor Erez Zadok at Stony Brook
266 +University and his team.
267 +
268 +This version of AUFS, aufs2 has several purposes.
269 +- to be reviewed easily and widely.
270 +- to make the source files simpler and smaller by dropping several
271 +  original features.
272 +
273 +Through this work, I found some bad things in aufs1 source code and
274 +fixed them. Some of the dropped features will be reverted in the future,
275 +but not all I'm afraid.
276 +Aufs2 supports linux-2.6.27 and later. If you want older kernel version
277 +support, try aufs1 from CVS on SourceForge.
278 +
279 +Note: it becomes clear that "Aufs was rejected. Let's give it up."
280 +According to Christoph Hellwig, linux rejects all union-type filesystems
281 +but UnionMount.
282 +<http://marc.info/?l=linux-kernel&m=123938533724484&w=2>
283 +
284 +
285 +1. Features
286 +----------------------------------------
287 +- unite several directories into a single virtual filesystem. The member
288 +  directory is called as a branch.
289 +- you can specify the permission flags to the branch, which are 'readonly',
290 +  'readwrite' and 'whiteout-able.'
291 +- by upper writable branch, internal copyup and whiteout, files/dirs on
292 +  readonly branch are modifiable logically.
293 +- dynamic branch manipulation, add, del.
294 +- etc...
295 +
296 +Also there are many enhancements in aufs1, such as:
297 +- readdir(3) in userspace.
298 +- keep inode number by external inode number table
299 +- keep the timestamps of file/dir in internal copyup operation
300 +- seekable directory, supporting NFS readdir.
301 +- support mmap(2) including /proc/PID/exe symlink, without page-copy
302 +- whiteout is hardlinked in order to reduce the consumption of inodes
303 +  on branch
304 +- do not copyup, nor create a whiteout when it is unnecessary
305 +- revert a single systemcall when an error occurs in aufs
306 +- remount interface instead of ioctl
307 +- maintain /etc/mtab by an external command, /sbin/mount.aufs.
308 +- loopback mounted filesystem as a branch
309 +- kernel thread for removing the dir who has a plenty of whiteouts
310 +- support copyup sparse file (a file which has a 'hole' in it)
311 +- default permission flags for branches
312 +- selectable permission flags for ro branch, whether whiteout can
313 +  exist or not
314 +- export via NFS.
315 +- support <sysfs>/fs/aufs and <debugfs>/aufs.
316 +- support multiple writable branches, some policies to select one
317 +  among multiple writable branches.
318 +- a new semantics for link(2) and rename(2) to support multiple
319 +  writable branches.
320 +- no glibc changes are required.
321 +- pseudo hardlink (hardlink over branches)
322 +- allow a direct access manually to a file on branch, e.g. bypassing aufs.
323 +  including NFS or remote filesystem branch.
324 +- userspace wrapper for pathconf(3)/fpathconf(3) with _PC_LINK_MAX.
325 +- and more...
326 +
327 +Currently these features are dropped temporary from this version, aufs2.
328 +See design/08plan.txt in detail.
329 +- test only the highest one for the directory permission (dirperm1)
330 +- show whiteout mode (shwh)
331 +- copyup on open (coo=)
332 +- nested mount, i.e. aufs as readonly no-whiteout branch of another aufs
333 +  (robr)
334 +- statistics of aufs thread (/sys/fs/aufs/stat)
335 +- delegation mode (dlgt)
336 +  a delegation of the internal branch access to support task I/O
337 +  accounting, which also supports Linux Security Modules (LSM) mainly
338 +  for Suse AppArmor.
339 +- intent.open/create (file open in a single lookup)
340 +
341 +Features or just an idea in the future (see also design/*.txt),
342 +- reorder the branch index without del/re-add.
343 +- permanent xino files for NFSD
344 +- an option for refreshing the opened files after add/del branches
345 +- 'move' policy for copy-up between two writable branches, after
346 +  checking free space.
347 +- O_DIRECT
348 +- light version, without branch manipulation. (unnecessary?)
349 +- copyup in userspace
350 +- inotify in userspace
351 +- readv/writev
352 +- xattr, acl
353 +
354 +
355 +2. Download
356 +----------------------------------------
357 +Kindly one of aufs user, the Center for Scientific Computing and Free
358 +Software (C3SL), Federal University of Parana offered me a public GIT
359 +tree space.
360 +
361 +There are three GIT trees, aufs2-2.6, aufs2-standalone and aufs2-util.
362 +While the aufs2-util is always necessary, you need either of aufs2-2.6
363 +or aufs2-standalone.
364 +
365 +The aufs2-2.6 tree includes the whole linux-2.6 GIT tree,
366 +git://git.kernel.org/.../torvalds/linux-2.6.git.
367 +And you cannot select CONFIG_AUFS_FS=m for this version, eg. you cannot
368 +build aufs2 as an externel kernel module.
369 +If you already have linux-2.6 GIT tree, you may want to pull and merge
370 +the "aufs2" branch from this tree.
371 +
372 +On the other hand, the aufs2-standalone tree has only aufs2 source files
373 +and a necessary patch, and you can select CONFIG_AUFS_FS=m. In other
374 +words, the aufs2-standalone tree is generated from aufs2-2.6 tree by,
375 +- extract new files and modifications.
376 +- generate some patch files from modifications.
377 +- generate a ChangeLog file from git-log.
378 +- commit the files newly and no log messages. this is not git-pull.
379 +
380 +Both of aufs2-2.6 and aufs2-standalone trees have a branch whose name is
381 +in form of "aufs2-xx" where "xx" represents the linux kernel version,
382 +"linux-2.6.xx".
383 +
384 +o aufs2-2.6 tree
385 +$ git clone --reference /your/linux-2.6/git/tree \
386 +       http://git.c3sl.ufpr.br/pub/scm/aufs/aufs2-2.6.git \
387 +       aufs2-2.6.git
388 +- if you don't have linux-2.6 GIT tree, then remove "--reference ..."
389 +$ cd aufs2-2.6.git
390 +$ git checkout origin/aufs2-xx # for instance, aufs2-27 for linux-2.6.27
391 +                               # aufs2 (no -xx) for the latest -rc version.
392 +
393 +o aufs2-standalone tree
394 +$ git clone http://git.c3sl.ufpr.br/pub/scm/aufs/aufs2-standalone.git \
395 +       aufs2-standalone.git
396 +$ cd aufs2-standalone.git
397 +$ git checkout origin/aufs2-xx # for instance, aufs2-27 for linux-2.6.27
398 +                               # aufs2 (no -xx) for the latest -rc version.
399 +
400 +o aufs2-util tree
401 +$ git clone http://git.c3sl.ufpr.br/pub/scm/aufs/aufs2-util.git \
402 +       aufs2-util.git
403 +$ cd aufs2-util.git
404 +- no particular tag/branch currently.
405 +
406 +o for advanced users
407 +$ git clone git://git.kernel.org/.../torvalds/linux-2.6.git linux-2.6.git
408 +  It will take very long time.
409 +
410 +$ cd linux-2.6.git
411 +$ git remote add aufs2 http://git.c3sl.ufpr.br/pub/scm/aufs/aufs2-2.6.git
412 +$ git checkout -b aufs2-27 v2.6.27
413 +$ git pull aufs2 aufs2-27
414 +  It may take long time again.
415 +  Once pulling completes, you've got linux-2.6.27 and aufs2 for it in a
416 +  branch named aufs2-27, and you can configure and build it.
417 +
418 +Or
419 +
420 +$ git checkout -t -b aufs2 master
421 +$ git pull aufs2 aufs2
422 +  then you've got the latest linux kernel and the latest aufs2 in a
423 +  branch named aufs2, and you can configure and build it.
424 +  But aufs is released once a week, so you may meet a compilation error
425 +  due to mismatching between the mainline and aufs2.
426 +
427 +Or you may want build linux-2.6.xx.yy instead of linux-2.6.xx, then here
428 +is an approach using linux-2.6-stable GIT tree.
429 +
430 +$ cd linux-2.6.git/..
431 +$ git clone -q --reference ./linux-2.6.git git://git.kernel.org/.../linux-2.6-stable.git \
432 +       linux-2.6-stable.git
433 +  It will take very long time.
434 +
435 +$ cd linux-2.6-stable.git
436 +$ git remote add aufs2 http://git.c3sl.ufpr.br/pub/scm/aufs/aufs2-2.6.git
437 +$ git checkout -b aufs2-27.1 v2.6.27.1
438 +$ git pull aufs2 aufs2-27
439 +  then you've got linux-2.6.27.1 and aufs2 for 2.6.27 in a branch named
440 +  aufs2-27.1, and you can configure and build it.
441 +  But the changes made by v2.6.xx.yy may conflict with aufs2-xx, since
442 +  aufs2-xx is for v2.6.xx only. In this case, you may find some patchces
443 +  for v2.6.xx.yy in aufs2-standalone.git#aufs2-xx branch if someone else
444 +  have ever requested me to support v2.6.xx.yy and I did it.
445 +
446 +You can also check what was changed by pulling aufs2.
447 +$ git diff v2.6.27.1..aufs2-27.1
448 +
449 +If you want to check the changed files other than fs/aufs, then try this.
450 +$ git diff v2.6.27.1..aufs2-27.1 |
451 +> awk '
452 +> /^diff / {new=1}
453 +> /^diff.*aufs/ {new=0}
454 +> new {print}
455 +> '
456 +
457 +
458 +3. Configuration and Compilation
459 +----------------------------------------
460 +Make sure you have git-checkout'ed the correct branch.
461 +
462 +For aufs2-2.6 tree,
463 +- enable CONFIG_EXPERIMENTAL and CONFIG_AUFS_FS.
464 +- set other aufs configurations if necessary.
465 +
466 +For aufs2-standalone tree,
467 +There are several ways to build.
468 +
469 +You may feel why aufs2-standalone.patch needs to export so many kernel
470 +symbols. Because you selected aufs2-standalone tree instead of aufs2-2.6
471 +tree. The number of necessary symbols to export essentially is zero.
472 +All other symbols are for the external module.
473 +If you don't like aufs2-standalone.patch, then try aufs2-2.6 tree.
474 +
475 +1.
476 +- apply ./aufs2-kbuild.patch to your kernel source files.
477 +- apply ./aufs2-base.patch too.
478 +- apply ./aufs2-standalone.patch too, if you have a plan to set
479 +  CONFIG_AUFS_FS=m. otherwise you don't need ./aufs2-standalone.patch.
480 +- copy ./{Documentation,fs,include} files to your kernel source tree.
481 +- enable CONFIG_EXPERIMENTAL and CONFIG_AUFS_FS, you can select either
482 +  =m or =y.
483 +- and build your kernel as usual.
484 +- install it and reboot your system.
485 +
486 +2.
487 +- module only (CONFIG_AUFS_FS=m).
488 +- apply ./aufs2-base.patch to your kernel source files.
489 +- apply ./aufs2-standalone.patch too.
490 +- build your kernel and reboot.
491 +- edit ./config.mk and set other aufs configurations if necessary.
492 +  Note: You should read ./fs/aufs/Kconfig carefully which describes
493 +  every aufs configurations.
494 +- build the module by simple "make".
495 +- you can specify ${KDIR} make variable which points to your kernel
496 +  source tree.
497 +- copy the build ./aufs.ko to /lib/modules/..., and run depmod -a (or
498 +  reboot simply).
499 +- no need to apply aufs2-kbuild.patch, nor copying source files to your
500 +  kernel source tree.
501 +
502 +And then,
503 +- read README in aufs2-util, build and install it
504 +- if you want to use readdir(3) in userspace or pathconf(3) wrapper,
505 +  then run "make install_ulib" too. And refer to the aufs manual in
506 +  detail.
507 +
508 +
509 +4. Usage
510 +----------------------------------------
511 +At first, make sure aufs2-util are installed, and please read the aufs
512 +manual, aufs.5 in aufs2-util.git tree.
513 +$ man -l aufs.5
514 +
515 +And then,
516 +$ mkdir /tmp/rw /tmp/aufs
517 +# mount -t aufs -o br=/tmp/rw:${HOME} none /tmp/aufs
518 +
519 +Here is another example. The result is equivalent.
520 +# mount -t aufs -o br=/tmp/rw=rw:${HOME}=ro none /tmp/aufs
521 +  Or
522 +# mount -t aufs -o br:/tmp/rw none /tmp/aufs
523 +# mount -o remount,append:${HOME} /tmp/aufs
524 +
525 +Then, you can see whole tree of your home dir through /tmp/aufs. If
526 +you modify a file under /tmp/aufs, the one on your home directory is
527 +not affected, instead the same named file will be newly created under
528 +/tmp/rw. And all of your modification to a file will be applied to
529 +the one under /tmp/rw. This is called the file based Copy on Write
530 +(COW) method.
531 +Aufs mount options are described in aufs.5.
532 +
533 +Additionally, there are some sample usages of aufs which are a
534 +diskless system with network booting, and LiveCD over NFS.
535 +See sample dir in CVS tree on SourceForge.
536 +
537 +
538 +5. Contact
539 +----------------------------------------
540 +When you have any problems or strange behaviour in aufs, please let me
541 +know with:
542 +- /proc/mounts (instead of the output of mount(8))
543 +- /sys/module/aufs/*
544 +- /sys/fs/aufs/* (if you have them)
545 +- /debug/aufs/* (if you have them)
546 +- linux kernel version
547 +  if your kernel is not plain, for example modified by distributor,
548 +  the url where i can download its source is necessary too.
549 +- aufs version which was printed at loading the module or booting the
550 +  system, instead of the date you downloaded.
551 +- configuration (define/undefine CONFIG_AUFS_xxx)
552 +- kernel configuration or /proc/config.gz (if you have it)
553 +- behaviour which you think to be incorrect
554 +- actual operation, reproducible one is better
555 +- mailto: aufs-users at lists.sourceforge.net
556 +
557 +Usually, I don't watch the Public Areas(Bugs, Support Requests, Patches,
558 +and Feature Requests) on SourceForge. Please join and write to
559 +aufs-users ML.
560 +
561 +
562 +6. Acknowledgements
563 +----------------------------------------
564 +Thanks to everyone who have tried and are using aufs, whoever
565 +have reported a bug or any feedback.
566 +
567 +Especially donors:
568 +Tomas Matejicek(slax.org) made a donation (much more than once).
569 +Dai Itasaka made a donation (2007/8).
570 +Chuck Smith made a donation (2008/4, 10 and 12).
571 +Henk Schoneveld made a donation (2008/9).
572 +Chih-Wei Huang, ASUS, CTC donated Eee PC 4G (2008/10).
573 +Francois Dupoux made a donation (2008/11).
574 +Bruno Cesar Ribas and Luis Carlos Erpen de Bona, C3SL serves public
575 +aufs2 GIT tree (2009/2).
576 +William Grant made a donation (2009/3).
577 +Patrick Lane made a donation (2009/4).
578 +The Mail Archive (mail-archive.com) made donations (2009/5).
579 +Nippy Networks (Ed Wildgoose) made a donation (2009/7).
580 +New Dream Network, LLC (www.dreamhost.com) made a donation (2009/11).
581 +
582 +Thank you very much.
583 +Donations are always, including future donations, very important and
584 +helpful for me to keep on developing aufs.
585 +
586 +
587 +7.
588 +----------------------------------------
589 +If you are an experienced user, no explanation is needed. Aufs is
590 +just a linux filesystem.
591 +
592 +
593 +Enjoy!
594 +
595 +# Local variables: ;
596 +# mode: text;
597 +# End: ;
598 diff --git a/Documentation/filesystems/aufs/design/01intro.txt b/Documentation/filesystems/aufs/design/01intro.txt
599 new file mode 100644
600 index 0000000..ac678c0
601 --- /dev/null
602 +++ b/Documentation/filesystems/aufs/design/01intro.txt
603 @@ -0,0 +1,137 @@
604 +
605 +# Copyright (C) 2005-2009 Junjiro R. Okajima
606 +# 
607 +# This program is free software; you can redistribute it and/or modify
608 +# it under the terms of the GNU General Public License as published by
609 +# the Free Software Foundation; either version 2 of the License, or
610 +# (at your option) any later version.
611 +# 
612 +# This program is distributed in the hope that it will be useful,
613 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
614 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
615 +# GNU General Public License for more details.
616 +# 
617 +# You should have received a copy of the GNU General Public License
618 +# along with this program; if not, write to the Free Software
619 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
620 +
621 +Introduction
622 +----------------------------------------
623 +
624 +aufs [ei ju: ef es] | [a u f s]
625 +1. abbrev. for "advanced multi-layered unification filesystem".
626 +2. abbrev. for "another unionfs".
627 +3. abbrev. for "auf das" in German which means "on the" in English.
628 +   Ex. "Butter aufs Brot"(G) means "butter onto bread"(E).
629 +   But "Filesystem aufs Filesystem" is hard to understand.
630 +
631 +AUFS is a filesystem with features:
632 +- multi layered stackable unification filesystem, the member directory
633 +  is called as a branch.
634 +- branch permission and attribute, 'readonly', 'real-readonly',
635 +  'readwrite', 'whiteout-able', 'link-able whiteout' and their
636 +  combination.
637 +- internal "file copy-on-write".
638 +- logical deletion, whiteout.
639 +- dynamic branch manipulation, adding, deleting and changing permission.
640 +- allow bypassing aufs, user's direct branch access.
641 +- external inode number translation table and bitmap which maintains the
642 +  persistent aufs inode number.
643 +- seekable directory, including NFS readdir.
644 +- file mapping, mmap and sharing pages.
645 +- pseudo-link, hardlink over branches.
646 +- loopback mounted filesystem as a branch.
647 +- several policies to select one among multiple writable branches.
648 +- revert a single systemcall when an error occurs in aufs.
649 +- and more...
650 +
651 +
652 +Multi Layered Stackable Unification Filesystem
653 +----------------------------------------------------------------------
654 +Most people already knows what it is.
655 +It is a filesystem which unifies several directories and provides a
656 +merged single directory. When users access a file, the access will be
657 +passed/re-directed/converted (sorry, I am not sure which English word is
658 +correct) to the real file on the member filesystem. The member
659 +filesystem is called 'lower filesystem' or 'branch' and has a mode
660 +'readonly' and 'readwrite.' And the deletion for a file on the lower
661 +readonly branch is handled by creating 'whiteout' on the upper writable
662 +branch.
663 +
664 +On LKML, there have been discussions about UnionMount (Jan Blunck and
665 +Bharata B Rao) and Unionfs (Erez Zadok). They took different approaches
666 +to implement the merged-view.
667 +The former tries putting it into VFS, and the latter implements as a
668 +separate filesystem.
669 +(If I misunderstand about these implementations, please let me know and
670 +I shall correct it. Because it is a long time ago when I read their
671 +source files last time).
672 +UnionMount's approach will be able to small, but may be hard to share
673 +branches between several UnionMount since the whiteout in it is
674 +implemented in the inode on branch filesystem and always
675 +shared. According to Bharata's post, readdir does not seems to be
676 +finished yet.
677 +Unionfs has a longer history. When I started implementing a stacking filesystem
678 +(Aug 2005), it already existed. It has virtual super_block, inode,
679 +dentry and file objects and they have an array pointing lower same kind
680 +objects. After contributing many patches for Unionfs, I re-started my
681 +project AUFS (Jun 2006).
682 +
683 +In AUFS, the structure of filesystem resembles to Unionfs, but I
684 +implemented my own ideas, approaches and enhancements and it became
685 +totally different one.
686 +
687 +
688 +Several characters/aspects of aufs
689 +----------------------------------------------------------------------
690 +
691 +Aufs has several characters or aspects.
692 +1. a filesystem, callee of VFS helper
693 +2. sub-VFS, caller of VFS helper for branches
694 +3. a virtual filesystem which maintains persistent inode number
695 +4. reader/writer of files on branches such like an application
696 +
697 +1. Caller of VFS Helper
698 +As an ordinary linux filesystem, aufs is a callee of VFS. For instance,
699 +unlink(2) from an application reaches sys_unlink() kernel function and
700 +then vfs_unlink() is called. vfs_unlink() is one of VFS helper and it
701 +calls filesystem specific unlink operation. Actually aufs implements the
702 +unlink operation but it behaves like a redirector.
703 +
704 +2. Caller of VFS Helper for Branches
705 +aufs_unlink() passes the unlink request to the branch filesystem as if
706 +it were called from VFS. So the called unlink operation of the branch
707 +filesystem acts as usual. As a caller of VFS helper, aufs should handle
708 +every necessary pre/post operation for the branch filesystem.
709 +- acquire the lock for the parent dir on a branch
710 +- lookup in a branch
711 +- revalidate dentry on a branch
712 +- mnt_want_write() for a branch
713 +- vfs_unlink() for a branch
714 +- mnt_drop_write() for a branch
715 +- release the lock on a branch
716 +
717 +3. Persistent Inode Number
718 +One of the most important issue for a filesystem is to maintain inode
719 +numbers. This is particularly important to support exporting a
720 +filesystem via NFS. Aufs is a virtual filesystem which doesn't have a
721 +backend block device for its own. But some storage is necessary to
722 +maintain inode number. It may be a large space and may not suit to keep
723 +in memory. Aufs rents some space from its first writable branch
724 +filesystem (by default) and creates file(s) on it. These files are
725 +created by aufs internally and removed soon (currently) keeping opened.
726 +Note: Because these files are removed, they are totally gone after
727 +      unmounting aufs. It means the inode numbers are not persistent
728 +      across unmount or reboot. I have a plan to make them really
729 +      persistent which will be important for aufs on NFS server.
730 +
731 +4. Read/Write Files Internally (copy-on-write)
732 +Because a branch can be readonly, when you write a file on it, aufs will
733 +"copy-up" it to the upper writable branch internally. And then write the
734 +originally requested thing to the file. Generally kernel doesn't
735 +open/read/write file actively. In aufs, even a single write may cause a
736 +internal "file copy". This behaviour is very similar to cp(1) command.
737 +
738 +Some people may think it is better to pass such work to user space
739 +helper, instead of doing in kernel space. Actually I am still thinking
740 +about it. But currently I have implemented it in kernel space.
741 diff --git a/Documentation/filesystems/aufs/design/02struct.txt b/Documentation/filesystems/aufs/design/02struct.txt
742 new file mode 100644
743 index 0000000..11cee07
744 --- /dev/null
745 +++ b/Documentation/filesystems/aufs/design/02struct.txt
746 @@ -0,0 +1,218 @@
747 +
748 +# Copyright (C) 2005-2009 Junjiro R. Okajima
749 +# 
750 +# This program is free software; you can redistribute it and/or modify
751 +# it under the terms of the GNU General Public License as published by
752 +# the Free Software Foundation; either version 2 of the License, or
753 +# (at your option) any later version.
754 +# 
755 +# This program is distributed in the hope that it will be useful,
756 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
757 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
758 +# GNU General Public License for more details.
759 +# 
760 +# You should have received a copy of the GNU General Public License
761 +# along with this program; if not, write to the Free Software
762 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
763 +
764 +Basic Aufs Internal Structure
765 +
766 +Superblock/Inode/Dentry/File Objects
767 +----------------------------------------------------------------------
768 +As like an ordinary filesystem, aufs has its own
769 +superblock/inode/dentry/file objects. All these objects have a
770 +dynamically allocated array and store the same kind of pointers to the
771 +lower filesystem, branch.
772 +For example, when you build a union with one readwrite branch and one
773 +readonly, mounted /au, /rw and /ro respectively.
774 +- /au = /rw + /ro
775 +- /ro/fileA exists but /rw/fileA
776 +
777 +Aufs lookup operation finds /ro/fileA and gets dentry for that. These
778 +pointers are stored in a aufs dentry. The array in aufs dentry will be,
779 +- [0] = NULL
780 +- [1] = /ro/fileA
781 +
782 +This style of an array is essentially same to the aufs
783 +superblock/inode/dentry/file objects.
784 +
785 +Because aufs supports manipulating branches, ie. add/delete/change
786 +dynamically, these objects has its own generation. When branches are
787 +changed, the generation in aufs superblock is incremented. And a
788 +generation in other object are compared when it is accessed.
789 +When a generation in other objects are obsoleted, aufs refreshes the
790 +internal array.
791 +
792 +
793 +Superblock
794 +----------------------------------------------------------------------
795 +Additionally aufs superblock has some data for policies to select one
796 +among multiple writable branches, XIB files, pseudo-links and kobject.
797 +See below in detail.
798 +About the policies which supports copy-down a directory, see policy.txt
799 +too.
800 +
801 +
802 +Branch and XINO(External Inode Number Translation Table)
803 +----------------------------------------------------------------------
804 +Every branch has its own xino (external inode number translation table)
805 +file. The xino file is created and unlinked by aufs internally. When two
806 +members of a union exist on the same filesystem, they share the single
807 +xino file.
808 +The struct of a xino file is simple, just a sequence of aufs inode
809 +numbers which is indexed by the lower inode number.
810 +In the above sample, assume the inode number of /ro/fileA is i111 and
811 +aufs assigns the inode number i999 for fileA. Then aufs writes 999 as
812 +4(8) bytes at 111 * 4(8) bytes offset in the xino file.
813 +
814 +When the inode numbers are not contiguous, the xino file will be sparse
815 +which has a hole in it and doesn't consume as much disk space as it
816 +might appear. If your branch filesystem consumes disk space for such
817 +holes, then you should specify 'xino=' option at mounting aufs.
818 +
819 +Also a writable branch has three kinds of "whiteout bases". All these
820 +are existed when the branch is joined to aufs and the names are
821 +whiteout-ed doubly, so that users will never see their names in aufs
822 +hierarchy.
823 +1. a regular file which will be linked to all whiteouts.
824 +2. a directory to store a pseudo-link.
825 +3. a directory to store an "orphan-ed" file temporary.
826 +
827 +1. Whiteout Base
828 +   When you remove a file on a readonly branch, aufs handles it as a
829 +   logical deletion and creates a whiteout on the upper writable branch
830 +   as a hardlink of this file in order not to consume inode on the
831 +   writable branch.
832 +2. Pseudo-link Dir
833 +   See below, Pseudo-link.
834 +3. Step-Parent Dir
835 +   When "fileC" exists on the lower readonly branch only and it is
836 +   opened and removed with its parent dir, and then user writes
837 +   something into it, then aufs copies-up fileC to this
838 +   directory. Because there is no other dir to store fileC. After
839 +   creating a file under this dir, the file is unlinked.
840 +
841 +Because aufs supports manipulating branches, ie. add/delete/change
842 +dynamically, a branch has its own id. When the branch order changes, aufs
843 +finds the new index by searching the branch id.
844 +
845 +
846 +Pseudo-link
847 +----------------------------------------------------------------------
848 +Assume "fileA" exists on the lower readonly branch only and it is
849 +hardlinked to "fileB" on the branch. When you write something to fileA,
850 +aufs copies-up it to the upper writable branch. Additionally aufs
851 +creates a hardlink under the Pseudo-link Directory of the writable
852 +branch. The inode of a pseudo-link is kept in aufs super_block as a
853 +simple list. If fileB is read after unlinking fileA, aufs returns
854 +filedata from the pseudo-link instead of the lower readonly
855 +branch. Because the pseudo-link is based upon the inode, to keep the
856 +inode number by xino (see above) is important.
857 +
858 +All the hardlinks under the Pseudo-link Directory of the writable branch
859 +should be restored in a proper location later. Aufs provides a utility
860 +to do this. The userspace helpers executed at remounting and unmounting
861 +aufs by default.
862 +
863 +
864 +XIB(external inode number bitmap)
865 +----------------------------------------------------------------------
866 +Addition to the xino file per a branch, aufs has an external inode number
867 +bitmap in a superblock object. It is also a file such like a xino file.
868 +It is a simple bitmap to mark whether the aufs inode number is in-use or
869 +not.
870 +To reduce the file I/O, aufs prepares a single memory page to cache xib.
871 +
872 +Aufs implements a feature to truncate/refresh both of xino and xib to
873 +reduce the number of consumed disk blocks for these files.
874 +
875 +
876 +Virtual or Vertical Dir
877 +----------------------------------------------------------------------
878 +In order to support multiple layers (branches), aufs readdir operation
879 +constructs a virtual dir block on memory. For readdir, aufs calls
880 +vfs_readdir() internally for each dir on branches, merges their entries
881 +with eliminating the whiteout-ed ones, and sets it to file (dir)
882 +object. So the file object has its entry list until it is closed. The
883 +entry list will be updated when the file position is zero and becomes
884 +old. This decision is made in aufs automatically.
885 +
886 +The dynamically allocated memory block for the name of entries has a
887 +unit of 512 bytes (by default) and stores the names contiguously (no
888 +padding). Another block for each entry is handled by kmem_cache too.
889 +During building dir blocks, aufs creates hash list and judging whether
890 +the entry is whiteouted by its upper branch or already listed.
891 +
892 +Some people may call it can be a security hole or invite DoS attack
893 +since the opened and once readdir-ed dir (file object) holds its entry
894 +list and becomes a pressure for system memory. But I'd say it is similar
895 +to files under /proc or /sys. The virtual files in them also holds a
896 +memory page (generally) while they are opened. When an idea to reduce
897 +memory for them is introduced, it will be applied to aufs too.
898 +For those who really hate this situation, I've developed readdir(3)
899 +library which operates this merging in userspace. You just need to set
900 +LD_PRELOAD environment variable, and aufs will not consume no memory in
901 +kernel space for readdir(3).
902 +
903 +
904 +Workqueue
905 +----------------------------------------------------------------------
906 +Aufs sometimes requires privilege access to a branch. For instance,
907 +in copy-up/down operation. When a user process is going to make changes
908 +to a file which exists in the lower readonly branch only, and the mode
909 +of one of ancestor directories may not be writable by a user
910 +process. Here aufs copy-up the file with its ancestors and they may
911 +require privilege to set its owner/group/mode/etc.
912 +This is a typical case of a application character of aufs (see
913 +Introduction).
914 +
915 +Aufs uses workqueue synchronously for this case. It creates its own
916 +workqueue. The workqueue is a kernel thread and has privilege. Aufs
917 +passes the request to call mkdir or write (for example), and wait for
918 +its completion. This approach solves a problem of a signal handler
919 +simply.
920 +If aufs didn't adopt the workqueue and changed the privilege of the
921 +process, and if the mkdir/write call arises SIGXFSZ or other signal,
922 +then the user process might gain a privilege or the generated core file
923 +was owned by a superuser. But I have a plan to switch to a new
924 +credential approach which will be introduced in linux-2.6.29.
925 +
926 +Also aufs uses the system global workqueue ("events" kernel thread) too
927 +for asynchronous tasks, such like handling inotify, re-creating a
928 +whiteout base and etc. This is unrelated to a privilege.
929 +Most of aufs operation tries acquiring a rw_semaphore for aufs
930 +superblock at the beginning, at the same time waits for the completion
931 +of all queued asynchronous tasks.
932 +
933 +
934 +Whiteout
935 +----------------------------------------------------------------------
936 +The whiteout in aufs is very similar to Unionfs's. That is represented
937 +by its filename. UnionMount takes an approach of a file mode, but I am
938 +afraid several utilities (find(1) or something) will have to support it.
939 +
940 +Basically the whiteout represents "logical deletion" which stops aufs to
941 +lookup further, but also it represents "dir is opaque" which also stop
942 +lookup.
943 +
944 +In aufs, rmdir(2) and rename(2) for dir uses whiteout alternatively.
945 +In order to make several functions in a single systemcall to be
946 +revertible, aufs adopts an approach to rename a directory to a temporary
947 +unique whiteouted name.
948 +For example, in rename(2) dir where the target dir already existed, aufs
949 +renames the target dir to a temporary unique whiteouted name before the
950 +actual rename on a branch and then handles other actions (make it opaque,
951 +update the attributes, etc). If an error happens in these actions, aufs
952 +simply renames the whiteouted name back and returns an error. If all are
953 +succeeded, aufs registers a function to remove the whiteouted unique
954 +temporary name completely and asynchronously to the system global
955 +workqueue.
956 +
957 +
958 +Copy-up
959 +----------------------------------------------------------------------
960 +It is a well-known feature or concept.
961 +When user modifies a file on a readonly branch, aufs operate "copy-up"
962 +internally and makes change to the new file on the upper writable branch.
963 +When the trigger systemcall does not update the timestamps of the parent
964 +dir, aufs reverts it after copy-up.
965 diff --git a/Documentation/filesystems/aufs/design/03lookup.txt b/Documentation/filesystems/aufs/design/03lookup.txt
966 new file mode 100644
967 index 0000000..7510fdb
968 --- /dev/null
969 +++ b/Documentation/filesystems/aufs/design/03lookup.txt
970 @@ -0,0 +1,104 @@
971 +
972 +# Copyright (C) 2005-2009 Junjiro R. Okajima
973 +# 
974 +# This program is free software; you can redistribute it and/or modify
975 +# it under the terms of the GNU General Public License as published by
976 +# the Free Software Foundation; either version 2 of the License, or
977 +# (at your option) any later version.
978 +# 
979 +# This program is distributed in the hope that it will be useful,
980 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
981 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
982 +# GNU General Public License for more details.
983 +# 
984 +# You should have received a copy of the GNU General Public License
985 +# along with this program; if not, write to the Free Software
986 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
987 +
988 +Lookup in a Branch
989 +----------------------------------------------------------------------
990 +Since aufs has a character of sub-VFS (see Introduction), it operates
991 +lookup for branches as VFS does. It may be a heavy work. Generally
992 +speaking struct nameidata is a bigger structure and includes many
993 +information. But almost all lookup operation in aufs is the simplest
994 +case, ie. lookup only an entry directly connected to its parent. Digging
995 +down the directory hierarchy is unnecessary.
996 +
997 +VFS has a function lookup_one_len() for that use, but it is not usable
998 +for a branch filesystem which requires struct nameidata. So aufs
999 +implements a simple lookup wrapper function. When a branch filesystem
1000 +allows NULL as nameidata, it calls lookup_one_len(). Otherwise it builds
1001 +a simplest nameidata and calls lookup_hash().
1002 +Here aufs applies "a principle in NFSD", ie. if the filesystem supports
1003 +NFS-export, then it has to support NULL as a nameidata parameter for
1004 +->create(), ->lookup() and ->d_revalidate(). So the lookup wrapper in
1005 +aufs tests if ->s_export_op in the branch is NULL or not.
1006 +
1007 +When a branch is a remote filesystem, aufs trusts its ->d_revalidate().
1008 +For d_revalidate, aufs implements three levels of revalidate tests. See
1009 +"Revalidate Dentry and UDBA" in detail.
1010 +
1011 +
1012 +Loopback Mount
1013 +----------------------------------------------------------------------
1014 +Basically aufs supports any type of filesystem and block device for a
1015 +branch (actually there are some exceptions). But it is prohibited to add
1016 +a loopback mounted one whose backend file exists in a filesystem which is
1017 +already added to aufs. The reason is to protect aufs from a recursive
1018 +lookup. If it was allowed, the aufs lookup operation might re-enter a
1019 +lookup for the loopback mounted branch in the same context, and will
1020 +cause a deadlock.
1021 +
1022 +
1023 +Revalidate Dentry and UDBA (User's Direct Branch Access)
1024 +----------------------------------------------------------------------
1025 +Generally VFS helpers re-validate a dentry as a part of lookup.
1026 +0. digging down the directory hierarchy.
1027 +1. lock the parent dir by its i_mutex.
1028 +2. lookup the final (child) entry.
1029 +3. revalidate it.
1030 +4. call the actual operation (create, unlink, etc.)
1031 +5. unlock the parent dir
1032 +
1033 +If the filesystem implements its ->d_revalidate() (step 3), then it is
1034 +called. Actually aufs implements it and checks the dentry on a branch is
1035 +still valid.
1036 +But it is not enough. Because aufs has to release the lock for the
1037 +parent dir on a branch at the end of ->lookup() (step 2) and
1038 +->d_revalidate() (step 3) while the i_mutex of the aufs dir is still
1039 +held by VFS.
1040 +If the file on a branch is changed directly, eg. bypassing aufs, after
1041 +aufs released the lock, then the subsequent operation may cause
1042 +something unpleasant result.
1043 +
1044 +This situation is a result of VFS architecture, ->lookup() and
1045 +->d_revalidate() is separated. But I never say it is wrong. It is a good
1046 +design from VFS's point of view. It is just not suitable for sub-VFS
1047 +character in aufs.
1048 +
1049 +Aufs supports such case by three level of revalidation which is
1050 +selectable by user.
1051 +1. Simple Revalidate
1052 +   Addition to the native flow in VFS's, confirm the child-parent
1053 +   relationship on the branch just after locking the parent dir on the
1054 +   branch in the "actual operation" (step 4). When this validation
1055 +   fails, aufs returns EBUSY. ->d_revalidate() (step 3) in aufs still
1056 +   checks the validation of the dentry on branches.
1057 +2. Monitor Changes Internally by Inotify
1058 +   Addition to above, in the "actual operation" (step 4) aufs re-lookup
1059 +   the dentry on the branch, and returns EBUSY if it finds different
1060 +   dentry.
1061 +   Additionally, aufs sets the inotify watch for every dir on branches
1062 +   during it is in cache. When the event is notified, aufs registers a
1063 +   function to kernel 'events' thread by schedule_work(). And the
1064 +   function sets some special status to the cached aufs dentry and inode
1065 +   private data. If they are not cached, then aufs has nothing to
1066 +   do. When the same file is accessed through aufs (step 0-3) later,
1067 +   aufs will detect the status and refresh all necessary data.
1068 +   In this mode, aufs has to ignore the event which is fired by aufs
1069 +   itself.
1070 +3. No Extra Validation
1071 +   This is the simplest test and doesn't add any additional revalidation
1072 +   test, and skip therevalidatin in step 4. It is useful and improves
1073 +   aufs performance when system surely hide the aufs branches from user,
1074 +   by over-mounting something (or another method).
1075 diff --git a/Documentation/filesystems/aufs/design/04branch.txt b/Documentation/filesystems/aufs/design/04branch.txt
1076 new file mode 100644
1077 index 0000000..5529d6a
1078 --- /dev/null
1079 +++ b/Documentation/filesystems/aufs/design/04branch.txt
1080 @@ -0,0 +1,76 @@
1081 +
1082 +# Copyright (C) 2005-2009 Junjiro R. Okajima
1083 +# 
1084 +# This program is free software; you can redistribute it and/or modify
1085 +# it under the terms of the GNU General Public License as published by
1086 +# the Free Software Foundation; either version 2 of the License, or
1087 +# (at your option) any later version.
1088 +# 
1089 +# This program is distributed in the hope that it will be useful,
1090 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1091 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1092 +# GNU General Public License for more details.
1093 +# 
1094 +# You should have received a copy of the GNU General Public License
1095 +# along with this program; if not, write to the Free Software
1096 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1097 +
1098 +Branch Manipulation
1099 +
1100 +Since aufs supports dynamic branch manipulation, ie. add/remove a branch
1101 +and changing its permission/attribute, there are a lot of works to do.
1102 +
1103 +
1104 +Add a Branch
1105 +----------------------------------------------------------------------
1106 +o Confirm the adding dir exists outside of aufs, including loopback
1107 +  mount.
1108 +- and other various attributes...
1109 +o Initialize the xino file and whiteout bases if necessary.
1110 +  See struct.txt.
1111 +
1112 +o Check the owner/group/mode of the directory
1113 +  When the owner/group/mode of the adding directory differs from the
1114 +  existing branch, aufs issues a warning because it may impose a
1115 +  security risk.
1116 +  For example, when a upper writable branch has a world writable empty
1117 +  top directory, a malicious user can create any files on the writable
1118 +  branch directly, like copy-up and modify manually. If something like
1119 +  /etc/{passwd,shadow} exists on the lower readonly branch but the upper
1120 +  writable branch, and the writable branch is world-writable, then a
1121 +  malicious guy may create /etc/passwd on the writable branch directly
1122 +  and the infected file will be valid in aufs.
1123 +  I am afraid it can be a security issue, but nothing to do except
1124 +  producing a warning.
1125 +
1126 +
1127 +Delete a Branch
1128 +----------------------------------------------------------------------
1129 +o Confirm the deleting branch is not busy
1130 +  To be general, there is one merit to adopt "remount" interface to
1131 +  manipulate branches. It is to discard caches. At deleting a branch,
1132 +  aufs checks the still cached (and connected) dentries and inodes. If
1133 +  there are any, then they are all in-use. An inode without its
1134 +  corresponding dentry can be alive alone (for example, inotify case).
1135 +
1136 +  For the cached one, aufs checks whether the same named entry exists on
1137 +  other branches.
1138 +  If the cached one is a directory, because aufs provides a merged view
1139 +  to users, as long as one dir is left on any branch aufs can show the
1140 +  dir to users. In this case, the branch can be removed from aufs.
1141 +  Otherwise aufs rejects deleting the branch.
1142 +
1143 +  If any file on the deleting branch is opened by aufs, then aufs
1144 +  rejects deleting.
1145 +
1146 +
1147 +Modify the Permission of a Branch
1148 +----------------------------------------------------------------------
1149 +o Re-initialize or remove the xino file and whiteout bases if necessary.
1150 +  See struct.txt.
1151 +
1152 +o rw --> ro: Confirm the modifying branch is not busy
1153 +  Aufs rejects the request if any of these conditions are true.
1154 +  - a file on the branch is mmap-ed.
1155 +  - a regular file on the branch is opened for write and there is no
1156 +    same named entry on the upper branch.
1157 diff --git a/Documentation/filesystems/aufs/design/05wbr_policy.txt b/Documentation/filesystems/aufs/design/05wbr_policy.txt
1158 new file mode 100644
1159 index 0000000..5f25684
1160 --- /dev/null
1161 +++ b/Documentation/filesystems/aufs/design/05wbr_policy.txt
1162 @@ -0,0 +1,65 @@
1163 +
1164 +# Copyright (C) 2005-2009 Junjiro R. Okajima
1165 +# 
1166 +# This program is free software; you can redistribute it and/or modify
1167 +# it under the terms of the GNU General Public License as published by
1168 +# the Free Software Foundation; either version 2 of the License, or
1169 +# (at your option) any later version.
1170 +# 
1171 +# This program is distributed in the hope that it will be useful,
1172 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1173 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1174 +# GNU General Public License for more details.
1175 +# 
1176 +# You should have received a copy of the GNU General Public License
1177 +# along with this program; if not, write to the Free Software
1178 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1179 +
1180 +Policies to Select One among Multiple Writable Branches
1181 +----------------------------------------------------------------------
1182 +When the number of writable branch is more than one, aufs has to decide
1183 +the target branch for file creation or copy-up. By default, the highest
1184 +writable branch which has the parent (or ancestor) dir of the target
1185 +file is chosen (top-down-parent policy).
1186 +By user's request, aufs implements some other policies to select the
1187 +writable branch, for file creation two policies, round-robin and
1188 +most-free-space policies. For copy-up three policies, top-down-parent,
1189 +bottom-up-parent and bottom-up policies.
1190 +
1191 +As expected, the round-robin policy selects the branch in circular. When
1192 +you have two writable branches and creates 10 new files, 5 files will be
1193 +created for each branch. mkdir(2) systemcall is an exception. When you
1194 +create 10 new directories, all will be created on the same branch.
1195 +And the most-free-space policy selects the one which has most free
1196 +space among the writable branches. The amount of free space will be
1197 +checked by aufs internally, and users can specify its time interval.
1198 +
1199 +The policies for copy-up is more simple,
1200 +top-down-parent is equivalent to the same named on in create policy,
1201 +bottom-up-parent selects the writable branch where the parent dir
1202 +exists and the nearest upper one from the copyup-source,
1203 +bottom-up selects the nearest upper writable branch from the
1204 +copyup-source, regardless the existence of the parent dir.
1205 +
1206 +There are some rules or exceptions to apply these policies.
1207 +- If there is a readonly branch above the policy-selected branch and
1208 +  the parent dir is marked as opaque (a variation of whiteout), or the
1209 +  target (creating) file is whiteout-ed on the upper readonly branch,
1210 +  then the result of the policy is ignored and the target file will be
1211 +  created on the nearest upper writable branch than the readonly branch.
1212 +- If there is a writable branch above the policy-selected branch and
1213 +  the parent dir is marked as opaque or the target file is whiteouted
1214 +  on the branch, then the result of the policy is ignored and the target
1215 +  file will be created on the highest one among the upper writable
1216 +  branches who has diropq or whiteout. In case of whiteout, aufs removes
1217 +  it as usual.
1218 +- link(2) and rename(2) systemcalls are exceptions in every policy.
1219 +  They try selecting the branch where the source exists as possible
1220 +  since copyup a large file will take long time. If it can't be,
1221 +  ie. the branch where the source exists is readonly, then they will
1222 +  follow the copyup policy.
1223 +- There is an exception for rename(2) when the target exists.
1224 +  If the rename target exists, aufs compares the index of the branches
1225 +  where the source and the target exists and selects the higher
1226 +  one. If the selected branch is readonly, then aufs follows the
1227 +  copyup policy.
1228 diff --git a/Documentation/filesystems/aufs/design/06fmode_exec.txt b/Documentation/filesystems/aufs/design/06fmode_exec.txt
1229 new file mode 100644
1230 index 0000000..ebc311d
1231 --- /dev/null
1232 +++ b/Documentation/filesystems/aufs/design/06fmode_exec.txt
1233 @@ -0,0 +1,33 @@
1234 +
1235 +# Copyright (C) 2005-2009 Junjiro R. Okajima
1236 +# 
1237 +# This program is free software; you can redistribute it and/or modify
1238 +# it under the terms of the GNU General Public License as published by
1239 +# the Free Software Foundation; either version 2 of the License, or
1240 +# (at your option) any later version.
1241 +# 
1242 +# This program is distributed in the hope that it will be useful,
1243 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1244 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1245 +# GNU General Public License for more details.
1246 +# 
1247 +# You should have received a copy of the GNU General Public License
1248 +# along with this program; if not, write to the Free Software
1249 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1250 +
1251 +FMODE_EXEC and deny_write()
1252 +----------------------------------------------------------------------
1253 +Generally Unix prevents an executing file from writing its filedata.
1254 +In linux it is implemented by deny_write() and allow_write().
1255 +When a file is executed by exec() family, open_exec() (and sys_uselib())
1256 +they opens the file and calls deny_write(). If the file is aufs's virtual
1257 +one, it has no meaning. The file which deny_write() is really necessary
1258 +is the file on a branch. But the FMODE_EXEC flag is not passed to
1259 +->open() operation. So aufs adopt a dirty trick.
1260 +
1261 +- in order to get FMODE_EXEC, aufs ->lookup() and ->d_revalidate() set
1262 +  nd->intent.open.file->private_data to nd->intent.open.flags temporary.
1263 +- in aufs ->open(), when FMODE_EXEC is set in file->private_data, it
1264 +  calls deny_write() for the file on a branch.
1265 +- when the aufs file is released, allow_write() for the file on a branch
1266 +  is called.
1267 diff --git a/Documentation/filesystems/aufs/design/07mmap.txt b/Documentation/filesystems/aufs/design/07mmap.txt
1268 new file mode 100644
1269 index 0000000..5d60fb9
1270 --- /dev/null
1271 +++ b/Documentation/filesystems/aufs/design/07mmap.txt
1272 @@ -0,0 +1,53 @@
1273 +
1274 +# Copyright (C) 2005-2009 Junjiro R. Okajima
1275 +# 
1276 +# This program is free software; you can redistribute it and/or modify
1277 +# it under the terms of the GNU General Public License as published by
1278 +# the Free Software Foundation; either version 2 of the License, or
1279 +# (at your option) any later version.
1280 +# 
1281 +# This program is distributed in the hope that it will be useful,
1282 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1283 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1284 +# GNU General Public License for more details.
1285 +# 
1286 +# You should have received a copy of the GNU General Public License
1287 +# along with this program; if not, write to the Free Software
1288 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1289 +
1290 +mmap(2) -- File Memory Mapping
1291 +----------------------------------------------------------------------
1292 +In aufs, the file-mapped pages are shared between the file on a branch
1293 +and the virtual one in aufs by overriding vm_operation, particularly
1294 +->fault().
1295 +
1296 +In aufs_mmap(),
1297 +- get and store vm_ops of the real file on a branch.
1298 +- map the file of aufs by generic_file_mmap() and set aufs's vm
1299 +  operations.
1300 +
1301 +In aufs_fault(),
1302 +- get the file of aufs from the passed vma, sleep if needed.
1303 +- get the real file on a branch from the aufs file.
1304 +- a race may happen. for instance a multithreaded library. so some lock
1305 +  is implemented.
1306 +- call ->fault() in the previously stored vm_ops with setting the
1307 +  real file on a branch to vm_file.
1308 +- restore vm_file and wake_up if someone else got sleep.
1309 +
1310 +When a branch is added to or deleted from aufs, the same-named file may
1311 +unveil and its contents will be replaced by the new one when a process
1312 +read(2) through previously opened file.
1313 +(Some users may not want to refresh the filedata. For such users, I
1314 +have a plan to implement a mount option 'refrof' which decides to
1315 +refresh the opened files or not. See plan.txt too.)
1316 +In this case, an already mapped file will not be updated since the
1317 +contents are a part of a process already and it should not be changed by
1318 +aufs branch manipulation. (Even if MAP_SHARED is specified, currently).
1319 +Of course, in case of the deleting branch has a busy file, it cannot be
1320 +deleted from the union.
1321 +
1322 +In Unionfs, it took an approach which the memory pages mapped to
1323 +filedata are copied from the lower (real) file into the Unionfs's
1324 +virtual one and handles it by address_space operations. Recently Unionfs
1325 +changed it to this approach which aufs adopted since Jul 2006.
1326 diff --git a/Documentation/filesystems/aufs/design/08export.txt b/Documentation/filesystems/aufs/design/08export.txt
1327 new file mode 100644
1328 index 0000000..8394348
1329 --- /dev/null
1330 +++ b/Documentation/filesystems/aufs/design/08export.txt
1331 @@ -0,0 +1,59 @@
1332 +
1333 +# Copyright (C) 2005-2009 Junjiro R. Okajima
1334 +# 
1335 +# This program is free software; you can redistribute it and/or modify
1336 +# it under the terms of the GNU General Public License as published by
1337 +# the Free Software Foundation; either version 2 of the License, or
1338 +# (at your option) any later version.
1339 +# 
1340 +# This program is distributed in the hope that it will be useful,
1341 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1342 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1343 +# GNU General Public License for more details.
1344 +# 
1345 +# You should have received a copy of the GNU General Public License
1346 +# along with this program; if not, write to the Free Software
1347 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1348 +
1349 +Export Aufs via NFS
1350 +----------------------------------------------------------------------
1351 +Here is an approach.
1352 +- like xino/xib, add a new file 'xigen' which stores aufs inode
1353 +  generation.
1354 +- iget_locked(): initialize aufs inode generation for a new inode, and
1355 +  store it in xigen file.
1356 +- destroy_inode(): increment aufs inode generation and store it in xigen
1357 +  file. it is necessary even if it is not unlinked, because any data of
1358 +  inode may be changed by UDBA.
1359 +- encode_fh(): for a root dir, simply return FILEID_ROOT. otherwise
1360 +  build file handle by
1361 +  + branch id (4 bytes)
1362 +  + superblock generation (4 bytes)
1363 +  + inode number (4 or 8 bytes)
1364 +  + parent dir inode number (4 or 8 bytes)
1365 +  + inode generation (4 bytes))
1366 +  + return value of exportfs_encode_fh() for the parent on a branch (4
1367 +    bytes)
1368 +  + file handle for a branch (by exportfs_encode_fh())
1369 +- fh_to_dentry():
1370 +  + find the index of a branch from its id in handle, and check it is
1371 +    still exist in aufs.
1372 +  + 1st level: get the inode number from handle and search it in cache.
1373 +  + 2nd level: if not found, get the parent inode number from handle and
1374 +    search it in cache. and then open the parent dir, find the matching
1375 +    inode number by vfs_readdir() and get its name, and call
1376 +    lookup_one_len() for the target dentry.
1377 +  + 3rd level: if the parent dir is not cached, call
1378 +    exportfs_decode_fh() for a branch and get the parent on a branch,
1379 +    build a pathname of it, convert it a pathname in aufs, call
1380 +    path_lookup(). now aufs gets a parent dir dentry, then handle it as
1381 +    the 2nd level.
1382 +  + to open the dir, aufs needs struct vfsmount. aufs keeps vfsmount
1383 +    for every branch, but not itself. to get this, (currently) aufs
1384 +    searches in current->nsproxy->mnt_ns list. it may not be a good
1385 +    idea, but I didn't get other approach.
1386 +  + test the generation of the gotten inode.
1387 +- every inode operation: they may get EBUSY due to UDBA. in this case,
1388 +  convert it into ESTALE for NFSD.
1389 +- readdir(): call lockdep_on/off() because filldir in NFSD calls
1390 +  lookup_one_len(), vfs_getattr(), encode_fh() and others.
1391 diff --git a/Documentation/filesystems/aufs/design/09shwh.txt b/Documentation/filesystems/aufs/design/09shwh.txt
1392 new file mode 100644
1393 index 0000000..ce0c633
1394 --- /dev/null
1395 +++ b/Documentation/filesystems/aufs/design/09shwh.txt
1396 @@ -0,0 +1,53 @@
1397 +
1398 +# Copyright (C) 2005-2009 Junjiro R. Okajima
1399 +# 
1400 +# This program is free software; you can redistribute it and/or modify
1401 +# it under the terms of the GNU General Public License as published by
1402 +# the Free Software Foundation; either version 2 of the License, or
1403 +# (at your option) any later version.
1404 +# 
1405 +# This program is distributed in the hope that it will be useful,
1406 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1407 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1408 +# GNU General Public License for more details.
1409 +# 
1410 +# You should have received a copy of the GNU General Public License
1411 +# along with this program; if not, write to the Free Software
1412 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1413 +
1414 +Show Whiteout Mode (shwh)
1415 +----------------------------------------------------------------------
1416 +Generally aufs hides the name of whiteouts. But in some cases, to show
1417 +them is very useful for users. For instance, creating a new middle layer
1418 +(branch) by merging existing layers.
1419 +
1420 +(borrowing aufs1 HOW-TO from a user, Michael Towers)
1421 +When you have three branches,
1422 +- Bottom: 'system', squashfs (underlying base system), read-only
1423 +- Middle: 'mods', squashfs, read-only
1424 +- Top: 'overlay', ram (tmpfs), read-write
1425 +
1426 +The top layer is loaded at boot time and saved at shutdown, to preserve
1427 +the changes made to the system during the session.
1428 +When larger changes have been made, or smaller changes have accumulated,
1429 +the size of the saved top layer data grows. At this point, it would be
1430 +nice to be able to merge the two overlay branches ('mods' and 'overlay')
1431 +and rewrite the 'mods' squashfs, clearing the top layer and thus
1432 +restoring save and load speed.
1433 +
1434 +This merging is simplified by the use of another aufs mount, of just the
1435 +two overlay branches using the 'shwh' option.
1436 +# mount -t aufs -o ro,shwh,br:/livesys/overlay=ro+wh:/livesys/mods=rr+wh \
1437 +       aufs /livesys/merge_union
1438 +
1439 +A merged view of these two branches is then available at
1440 +/livesys/merge_union, and the new feature is that the whiteouts are
1441 +visible!
1442 +Note that in 'shwh' mode the aufs mount must be 'ro', which will disable
1443 +writing to all branches. Also the default mode for all branches is 'ro'.
1444 +It is now possible to save the combined contents of the two overlay
1445 +branches to a new squashfs, e.g.:
1446 +# mksquashfs /livesys/merge_union /path/to/newmods.squash
1447 +
1448 +This new squashfs archive can be stored on the boot device and the
1449 +initramfs will use it to replace the old one at the next boot.
1450 diff --git a/Documentation/filesystems/aufs/design/99plan.txt b/Documentation/filesystems/aufs/design/99plan.txt
1451 new file mode 100644
1452 index 0000000..78d1f0e
1453 --- /dev/null
1454 +++ b/Documentation/filesystems/aufs/design/99plan.txt
1455 @@ -0,0 +1,96 @@
1456 +
1457 +# Copyright (C) 2005-2009 Junjiro R. Okajima
1458 +# 
1459 +# This program is free software; you can redistribute it and/or modify
1460 +# it under the terms of the GNU General Public License as published by
1461 +# the Free Software Foundation; either version 2 of the License, or
1462 +# (at your option) any later version.
1463 +# 
1464 +# This program is distributed in the hope that it will be useful,
1465 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
1466 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1467 +# GNU General Public License for more details.
1468 +# 
1469 +# You should have received a copy of the GNU General Public License
1470 +# along with this program; if not, write to the Free Software
1471 +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1472 +
1473 +Plan
1474 +
1475 +Restoring some features which was implemented in aufs1.
1476 +They were dropped in aufs2 in order to make source files simpler and
1477 +easier to be reviewed.
1478 +
1479 +
1480 +Test Only the Highest One for the Directory Permission (dirperm1 option)
1481 +----------------------------------------------------------------------
1482 +Let's try case study.
1483 +- aufs has two branches, upper readwrite and lower readonly.
1484 +  /au = /rw + /ro
1485 +- "dirA" exists under /ro, but /rw. and its mode is 0700.
1486 +- user invoked "chmod a+rx /au/dirA"
1487 +- then "dirA" becomes world readable?
1488 +
1489 +In this case, /ro/dirA is still 0700 since it exists in readonly branch,
1490 +or it may be a natively readonly filesystem. If aufs respects the lower
1491 +branch, it should not respond readdir request from other users. But user
1492 +allowed it by chmod. Should really aufs rejects showing the entries
1493 +under /ro/dirA?
1494 +
1495 +To be honest, I don't have a best solution for this case. So I
1496 +implemented 'dirperm1' and 'nodirperm1' option in aufs1, and leave it to
1497 +users.
1498 +When dirperm1 is specified, aufs checks only the highest one for the
1499 +directory permission, and shows the entries. Otherwise, as usual, checks
1500 +every dir existing on all branches and rejects the request.
1501 +
1502 +As a side effect, dirperm1 option improves the performance of aufs
1503 +because the number of permission check is reduced.
1504 +
1505 +
1506 +Being Another Aufs's Readonly Branch (robr)
1507 +----------------------------------------------------------------------
1508 +Aufs1 allows aufs to be another aufs's readonly branch.
1509 +This feature was developed by a user's request. But it may not be used
1510 +currecnly.
1511 +
1512 +
1513 +Copy-up on Open (coo=)
1514 +----------------------------------------------------------------------
1515 +By default the internal copy-up is executed when it is really necessary.
1516 +It is not done when a file is opened for writing, but when write(2) is
1517 +done. Users who have many (over 100) branches want to know and analyse
1518 +when and what file is copied-up. To insert a new upper branch which
1519 +contains such files only may improve the performance of aufs.
1520 +
1521 +Aufs1 implemented "coo=none | leaf | all" option.
1522 +
1523 +
1524 +Refresh the Opened File (refrof)
1525 +----------------------------------------------------------------------
1526 +This option is implemented in aufs1 but incomplete.
1527 +
1528 +When user reads from a file, he expects to get its latest filedata
1529 +generally. If the file is removed and a new same named file is created,
1530 +the content he gets is unchanged, ie. the unlinked filedata.
1531 +
1532 +Let's try case study again.
1533 +- aufs has two branches.
1534 +  /au = /rw + /ro
1535 +- "fileA" exists under /ro, but /rw.
1536 +- user opened "/au/fileA".
1537 +- he or someone else inserts a branch (/new) between /rw and /ro.
1538 +  /au = /rw + /new + /ro
1539 +- the new branch has "fileA".
1540 +- user reads from the opened "fileA"
1541 +- which filedata should aufs return, from /ro or /new?
1542 +
1543 +Some people says it has to be "from /ro" and it is a semantics of Unix.
1544 +The others say it should be "from /new" because the file is not removed
1545 +and it is equivalent to the case of someone else modifies the file.
1546 +
1547 +Here again I don't have a best and final answer. I got an idea to
1548 +implement 'refrof' and 'norefrof' option. When 'refrof' (REFResh the
1549 +Opened File) is specified (by default), aufs returns the filedata from
1550 +/new.
1551 +Otherwise from /new.
1552 diff --git a/fs/Kconfig b/fs/Kconfig
1553 index bd989c0..8af22e4 100644
1554 --- a/fs/Kconfig
1555 +++ b/fs/Kconfig
1556 @@ -1541,6 +1541,8 @@ config UFS_DEBUG
1557           Y here.  This will result in _many_ additional debugging messages to be
1558           written to the system log.
1559  
1560 +source "fs/aufs/Kconfig"
1561 +
1562  endmenu
1563  
1564  menuconfig NETWORK_FILESYSTEMS
1565 diff --git a/fs/Makefile b/fs/Makefile
1566 index 0871ab5..364e863 100644
1567 --- a/fs/Makefile
1568 +++ b/fs/Makefile
1569 @@ -123,3 +123,4 @@ obj-$(CONFIG_HPPFS)         += hppfs/
1570  obj-$(CONFIG_DEBUG_FS)         += debugfs/
1571  obj-$(CONFIG_OCFS2_FS)         += ocfs2/
1572  obj-$(CONFIG_GFS2_FS)           += gfs2/
1573 +obj-$(CONFIG_AUFS_FS)           += aufs/
1574 diff --git a/fs/aufs/Kconfig b/fs/aufs/Kconfig
1575 new file mode 100644
1576 index 0000000..12e4327
1577 --- /dev/null
1578 +++ b/fs/aufs/Kconfig
1579 @@ -0,0 +1,136 @@
1580 +config AUFS_FS
1581 +       bool "Aufs (Advanced multi layered unification filesystem) support"
1582 +       depends on EXPERIMENTAL
1583 +       help
1584 +       Aufs is a stackable unification filesystem such as Unionfs,
1585 +       which unifies several directories and provides a merged single
1586 +       directory.
1587 +       In the early days, aufs was entirely re-designed and
1588 +       re-implemented Unionfs Version 1.x series. Introducing many
1589 +       original ideas, approaches and improvements, it becomes totally
1590 +       different from Unionfs while keeping the basic features.
1591 +
1592 +if AUFS_FS
1593 +choice
1594 +       prompt "Maximum number of branches"
1595 +       default AUFS_BRANCH_MAX_127
1596 +       help
1597 +       Specifies the maximum number of branches (or member directories)
1598 +       in a single aufs. The larger value consumes more system
1599 +       resources and has a minor impact to performance.
1600 +config AUFS_BRANCH_MAX_127
1601 +       bool "127"
1602 +       help
1603 +       Specifies the maximum number of branches (or member directories)
1604 +       in a single aufs. The larger value consumes more system
1605 +       resources and has a minor impact to performance.
1606 +config AUFS_BRANCH_MAX_511
1607 +       bool "511"
1608 +       help
1609 +       Specifies the maximum number of branches (or member directories)
1610 +       in a single aufs. The larger value consumes more system
1611 +       resources and has a minor impact to performance.
1612 +config AUFS_BRANCH_MAX_1023
1613 +       bool "1023"
1614 +       help
1615 +       Specifies the maximum number of branches (or member directories)
1616 +       in a single aufs. The larger value consumes more system
1617 +       resources and has a minor impact to performance.
1618 +config AUFS_BRANCH_MAX_32767
1619 +       bool "32767"
1620 +       help
1621 +       Specifies the maximum number of branches (or member directories)
1622 +       in a single aufs. The larger value consumes more system
1623 +       resources and has a minor impact to performance.
1624 +endchoice
1625 +
1626 +config AUFS_HINOTIFY
1627 +       bool "Use inotify to detect actions on a branch"
1628 +       depends on INOTIFY
1629 +       help
1630 +       If you want to modify files on branches directly, eg. bypassing aufs,
1631 +       and want aufs to detect the changes of them fully, then enable this
1632 +       option and use 'udba=inotify' mount option.
1633 +       It will have a negative impact to the performance.
1634 +       See detail in aufs.5.
1635 +
1636 +config AUFS_EXPORT
1637 +       bool "NFS-exportable aufs"
1638 +       depends on EXPORTFS = y
1639 +       help
1640 +       If you want to export your mounted aufs via NFS, then enable this
1641 +       option. There are several requirements for this configuration.
1642 +       See detail in aufs.5.
1643 +
1644 +config AUFS_INO_T_64
1645 +       bool
1646 +       depends on AUFS_EXPORT
1647 +       depends on 64BIT && !(ALPHA || S390)
1648 +       default y
1649 +       help
1650 +       Automatic configuration for internal use.
1651 +       /* typedef unsigned long/int __kernel_ino_t */
1652 +       /* alpha and s390x are int */
1653 +
1654 +config AUFS_RDU
1655 +       bool "Readdir in userspace"
1656 +       help
1657 +       If you have millions of files under a single aufs directory, and
1658 +       meet the out of memory, then enable this option and set
1659 +       environment variables for your readdir(3).
1660 +       See detail in aufs.5.
1661 +
1662 +config AUFS_SP_IATTR
1663 +       bool "Respect the attributes (mtime/ctime mainly) of special files"
1664 +       help
1665 +       When you write something to a special file, some attributes of it
1666 +       (mtime/ctime mainly) may be updated. Generally such updates are
1667 +       less important (actually some device drivers and NFS ignore
1668 +       it). But some applications (such like test program) requires
1669 +       such updates. If you need these updates, then enable this
1670 +       configuration which introduces some overhead.
1671 +       Currently this configuration handles FIFO only.
1672 +
1673 +config AUFS_SHWH
1674 +       bool "Show whiteouts"
1675 +       help
1676 +       If you want to make the whiteouts in aufs visible, then enable
1677 +       this option and specify 'shwh' mount option. Although it may
1678 +       sounds like philosophy or something, but in technically it
1679 +       simply shows the name of whiteout with keeping its behaviour.
1680 +
1681 +config AUFS_BR_RAMFS
1682 +       bool "Ramfs (initramfs/rootfs) as an aufs branch"
1683 +       help
1684 +       If you want to use ramfs as an aufs branch fs, then enable this
1685 +       option. Generally tmpfs is recommended.
1686 +       Aufs prohibited them to be a branch fs by default, because
1687 +       initramfs becomes unusable after switch_root or something
1688 +       generally. If you sets initramfs as an aufs branch and boot your
1689 +       system by switch_root, you will meet a problem easily since the
1690 +       files in initramfs may be inaccessible.
1691 +       Unless you are going to use ramfs as an aufs branch fs without
1692 +       switch_root or something, leave it N.
1693 +
1694 +config AUFS_BDEV_LOOP
1695 +       bool
1696 +       depends on BLK_DEV_LOOP
1697 +       default y
1698 +       help
1699 +       Automatic configuration for internal use.
1700 +       Convert =[ym] into =y.
1701 +
1702 +config AUFS_DEBUG
1703 +       bool "Debug aufs"
1704 +       help
1705 +       Enable this to compile aufs internal debug code.
1706 +       It will have a negative impact to the performance.
1707 +
1708 +config AUFS_MAGIC_SYSRQ
1709 +       bool
1710 +       depends on AUFS_DEBUG && MAGIC_SYSRQ
1711 +       default y
1712 +       help
1713 +       Automatic configuration for internal use.
1714 +       When aufs supports Magic SysRq, enabled automatically.
1715 +endif
1716 diff --git a/fs/aufs/Makefile b/fs/aufs/Makefile
1717 new file mode 100644
1718 index 0000000..29411e9
1719 --- /dev/null
1720 +++ b/fs/aufs/Makefile
1721 @@ -0,0 +1,23 @@
1722 +
1723 +include ${srctree}/${src}/magic.mk
1724 +
1725 +obj-$(CONFIG_AUFS_FS) += aufs.o
1726 +aufs-y := module.o sbinfo.o super.o branch.o xino.o sysaufs.o opts.o \
1727 +       wkq.o vfsub.o dcsub.o \
1728 +       cpup.o whout.o plink.o wbr_policy.o \
1729 +       dinfo.o dentry.o \
1730 +       finfo.o file.o f_op.o \
1731 +       dir.o vdir.o \
1732 +       iinfo.o inode.o i_op.o i_op_add.o i_op_del.o i_op_ren.o \
1733 +       ioctl.o
1734 +
1735 +# all are boolean
1736 +aufs-$(CONFIG_SYSFS) += sysfs.o
1737 +aufs-$(CONFIG_DEBUG_FS) += dbgaufs.o
1738 +aufs-$(CONFIG_AUFS_BDEV_LOOP) += loop.o
1739 +aufs-$(CONFIG_AUFS_HINOTIFY) += hinotify.o
1740 +aufs-$(CONFIG_AUFS_EXPORT) += export.o
1741 +aufs-$(CONFIG_AUFS_RDU) += rdu.o
1742 +aufs-$(CONFIG_AUFS_SP_IATTR) += f_op_sp.o
1743 +aufs-$(CONFIG_AUFS_DEBUG) += debug.o
1744 +aufs-$(CONFIG_AUFS_MAGIC_SYSRQ) += sysrq.o
1745 diff --git a/fs/aufs/aufs.h b/fs/aufs/aufs.h
1746 new file mode 100644
1747 index 0000000..49bada2
1748 --- /dev/null
1749 +++ b/fs/aufs/aufs.h
1750 @@ -0,0 +1,59 @@
1751 +/*
1752 + * Copyright (C) 2005-2009 Junjiro R. Okajima
1753 + *
1754 + * This program, aufs is free software; you can redistribute it and/or modify
1755 + * it under the terms of the GNU General Public License as published by
1756 + * the Free Software Foundation; either version 2 of the License, or
1757 + * (at your option) any later version.
1758 + *
1759 + * This program is distributed in the hope that it will be useful,
1760 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1761 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1762 + * GNU General Public License for more details.
1763 + *
1764 + * You should have received a copy of the GNU General Public License
1765 + * along with this program; if not, write to the Free Software
1766 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1767 + */
1768 +
1769 +/*
1770 + * all header files
1771 + */
1772 +
1773 +#ifndef __AUFS_H__
1774 +#define __AUFS_H__
1775 +
1776 +#ifdef __KERNEL__
1777 +
1778 +#define AuStub(type, name, body, ...) \
1779 +       static inline type name(__VA_ARGS__) { body; }
1780 +
1781 +#define AuStubVoid(name, ...) \
1782 +       AuStub(void, name, , __VA_ARGS__)
1783 +#define AuStubInt0(name, ...) \
1784 +       AuStub(int, name, return 0, __VA_ARGS__)
1785 +
1786 +#include "debug.h"
1787 +
1788 +#include "branch.h"
1789 +#include "cpup.h"
1790 +#include "dcsub.h"
1791 +#include "dbgaufs.h"
1792 +#include "dentry.h"
1793 +#include "dir.h"
1794 +#include "file.h"
1795 +#include "fstype.h"
1796 +#include "inode.h"
1797 +#include "loop.h"
1798 +#include "module.h"
1799 +#include "opts.h"
1800 +#include "rwsem.h"
1801 +#include "spl.h"
1802 +#include "super.h"
1803 +#include "sysaufs.h"
1804 +#include "vfsub.h"
1805 +#include "whout.h"
1806 +#include "wkq.h"
1807 +
1808 +#endif /* __KERNEL__ */
1809 +#endif /* __AUFS_H__ */
1810 diff --git a/fs/aufs/branch.c b/fs/aufs/branch.c
1811 new file mode 100644
1812 index 0000000..2717e9e
1813 --- /dev/null
1814 +++ b/fs/aufs/branch.c
1815 @@ -0,0 +1,978 @@
1816 +/*
1817 + * Copyright (C) 2005-2009 Junjiro R. Okajima
1818 + *
1819 + * This program, aufs is free software; you can redistribute it and/or modify
1820 + * it under the terms of the GNU General Public License as published by
1821 + * the Free Software Foundation; either version 2 of the License, or
1822 + * (at your option) any later version.
1823 + *
1824 + * This program is distributed in the hope that it will be useful,
1825 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1826 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1827 + * GNU General Public License for more details.
1828 + *
1829 + * You should have received a copy of the GNU General Public License
1830 + * along with this program; if not, write to the Free Software
1831 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
1832 + */
1833 +
1834 +/*
1835 + * branch management
1836 + */
1837 +
1838 +#include <linux/file.h>
1839 +#include <linux/statfs.h>
1840 +#include "aufs.h"
1841 +
1842 +/*
1843 + * free a single branch
1844 + */
1845 +static void au_br_do_free(struct au_branch *br)
1846 +{
1847 +       int i;
1848 +       struct au_wbr *wbr;
1849 +
1850 +       if (br->br_xino.xi_file)
1851 +               fput(br->br_xino.xi_file);
1852 +       mutex_destroy(&br->br_xino.xi_nondir_mtx);
1853 +
1854 +       AuDebugOn(atomic_read(&br->br_count));
1855 +
1856 +       wbr = br->br_wbr;
1857 +       if (wbr) {
1858 +               for (i = 0; i < AuBrWh_Last; i++)
1859 +                       dput(wbr->wbr_wh[i]);
1860 +               AuDebugOn(atomic_read(&wbr->wbr_wh_running));
1861 +               AuRwDestroy(&wbr->wbr_wh_rwsem);
1862 +       }
1863 +
1864 +       /* some filesystems acquire extra lock */
1865 +       lockdep_off();
1866 +       mntput(br->br_mnt);
1867 +       lockdep_on();
1868 +
1869 +       kfree(wbr);
1870 +       kfree(br);
1871 +}
1872 +
1873 +/*
1874 + * frees all branches
1875 + */
1876 +void au_br_free(struct au_sbinfo *sbinfo)
1877 +{
1878 +       aufs_bindex_t bmax;
1879 +       struct au_branch **br;
1880 +
1881 +       AuRwMustWriteLock(&sbinfo->si_rwsem);
1882 +
1883 +       bmax = sbinfo->si_bend + 1;
1884 +       br = sbinfo->si_branch;
1885 +       while (bmax--)
1886 +               au_br_do_free(*br++);
1887 +}
1888 +
1889 +/*
1890 + * find the index of a branch which is specified by @br_id.
1891 + */
1892 +int au_br_index(struct super_block *sb, aufs_bindex_t br_id)
1893 +{
1894 +       aufs_bindex_t bindex, bend;
1895 +
1896 +       bend = au_sbend(sb);
1897 +       for (bindex = 0; bindex <= bend; bindex++)
1898 +               if (au_sbr_id(sb, bindex) == br_id)
1899 +                       return bindex;
1900 +       return -1;
1901 +}
1902 +
1903 +/* ---------------------------------------------------------------------- */
1904 +
1905 +/*
1906 + * add a branch
1907 + */
1908 +
1909 +static int test_overlap(struct super_block *sb, struct dentry *h_d1,
1910 +                       struct dentry *h_d2)
1911 +{
1912 +       if (unlikely(h_d1 == h_d2))
1913 +               return 1;
1914 +       return !!au_test_subdir(h_d1, h_d2)
1915 +               || !!au_test_subdir(h_d2, h_d1)
1916 +               || au_test_loopback_overlap(sb, h_d1, h_d2)
1917 +               || au_test_loopback_overlap(sb, h_d2, h_d1);
1918 +}
1919 +
1920 +/*
1921 + * returns a newly allocated branch. @new_nbranch is a number of branches
1922 + * after adding a branch.
1923 + */
1924 +static struct au_branch *au_br_alloc(struct super_block *sb, int new_nbranch,
1925 +                                    int perm)
1926 +{
1927 +       struct au_branch *add_branch;
1928 +       struct dentry *root;
1929 +
1930 +       root = sb->s_root;
1931 +       add_branch = kmalloc(sizeof(*add_branch), GFP_NOFS);
1932 +       if (unlikely(!add_branch))
1933 +               goto out;
1934 +
1935 +       add_branch->br_wbr = NULL;
1936 +       if (au_br_writable(perm)) {
1937 +               /* may be freed separately at changing the branch permission */
1938 +               add_branch->br_wbr = kmalloc(sizeof(*add_branch->br_wbr),
1939 +                                            GFP_NOFS);
1940 +               if (unlikely(!add_branch->br_wbr))
1941 +                       goto out_br;
1942 +       }
1943 +
1944 +       if (unlikely(au_sbr_realloc(au_sbi(sb), new_nbranch)
1945 +                    || au_di_realloc(au_di(root), new_nbranch)
1946 +                    || au_ii_realloc(au_ii(root->d_inode), new_nbranch)))
1947 +               goto out_wbr;
1948 +       return add_branch; /* success */
1949 +
1950 + out_wbr:
1951 +       kfree(add_branch->br_wbr);
1952 + out_br:
1953 +       kfree(add_branch);
1954 + out:
1955 +       return ERR_PTR(-ENOMEM);
1956 +}
1957 +
1958 +/*
1959 + * test if the branch permission is legal or not.
1960 + */
1961 +static int test_br(struct inode *inode, int brperm, char *path)
1962 +{
1963 +       int err;
1964 +
1965 +       err = 0;
1966 +       if (unlikely(au_br_writable(brperm) && IS_RDONLY(inode))) {
1967 +               AuErr("write permission for readonly mount or inode, %s\n",
1968 +                     path);
1969 +               err = -EINVAL;
1970 +       }
1971 +
1972 +       return err;
1973 +}
1974 +
1975 +/*
1976 + * returns:
1977 + * 0: success, the caller will add it
1978 + * plus: success, it is already unified, the caller should ignore it
1979 + * minus: error
1980 + */
1981 +static int test_add(struct super_block *sb, struct au_opt_add *add, int remount)
1982 +{
1983 +       int err;
1984 +       aufs_bindex_t bend, bindex;
1985 +       struct dentry *root;
1986 +       struct inode *inode, *h_inode;
1987 +
1988 +       root = sb->s_root;
1989 +       bend = au_sbend(sb);
1990 +       if (unlikely(bend >= 0
1991 +                    && au_find_dbindex(root, add->path.dentry) >= 0)) {
1992 +               err = 1;
1993 +               if (!remount) {
1994 +                       err = -EINVAL;
1995 +                       AuErr("%s duplicated\n", add->pathname);
1996 +               }
1997 +               goto out;
1998 +       }
1999 +
2000 +       err = -ENOSPC; /* -E2BIG; */
2001 +       if (unlikely(AUFS_BRANCH_MAX <= add->bindex
2002 +                    || AUFS_BRANCH_MAX - 1 <= bend)) {
2003 +               AuErr("number of branches exceeded %s\n", add->pathname);
2004 +               goto out;
2005 +       }
2006 +
2007 +       err = -EDOM;
2008 +       if (unlikely(add->bindex < 0 || bend + 1 < add->bindex)) {
2009 +               AuErr("bad index %d\n", add->bindex);
2010 +               goto out;
2011 +       }
2012 +
2013 +       inode = add->path.dentry->d_inode;
2014 +       err = -ENOENT;
2015 +       if (unlikely(!inode->i_nlink)) {
2016 +               AuErr("no existence %s\n", add->pathname);
2017 +               goto out;
2018 +       }
2019 +
2020 +       err = -EINVAL;
2021 +       if (unlikely(inode->i_sb == sb)) {
2022 +               AuErr("%s must be outside\n", add->pathname);
2023 +               goto out;
2024 +       }
2025 +
2026 +       if (unlikely(au_test_fs_unsuppoted(inode->i_sb))) {
2027 +               AuErr("unsupported filesystem, %s (%s)\n",
2028 +                     add->pathname, au_sbtype(inode->i_sb));
2029 +               goto out;
2030 +       }
2031 +
2032 +       err = test_br(add->path.dentry->d_inode, add->perm, add->pathname);
2033 +       if (unlikely(err))
2034 +               goto out;
2035 +
2036 +       if (bend < 0)
2037 +               return 0; /* success */
2038 +
2039 +       err = -EINVAL;
2040 +       for (bindex = 0; bindex <= bend; bindex++)
2041 +               if (unlikely(test_overlap(sb, add->path.dentry,
2042 +                                         au_h_dptr(root, bindex)))) {
2043 +                       AuErr("%s is overlapped\n", add->pathname);
2044 +                       goto out;
2045 +               }
2046 +
2047 +       err = 0;
2048 +       if (au_opt_test(au_mntflags(sb), WARN_PERM)) {
2049 +               h_inode = au_h_dptr(root, 0)->d_inode;
2050 +               if ((h_inode->i_mode & S_IALLUGO) != (inode->i_mode & S_IALLUGO)
2051 +                   || h_inode->i_uid != inode->i_uid
2052 +                   || h_inode->i_gid != inode->i_gid)
2053 +                       AuWarn("uid/gid/perm %s %u/%u/0%o, %u/%u/0%o\n",
2054 +                              add->pathname,
2055 +                              inode->i_uid, inode->i_gid,
2056 +                              (inode->i_mode & S_IALLUGO),
2057 +                              h_inode->i_uid, h_inode->i_gid,
2058 +                              (h_inode->i_mode & S_IALLUGO));
2059 +       }
2060 +
2061 + out:
2062 +       return err;
2063 +}
2064 +
2065 +/*
2066 + * initialize or clean the whiteouts for an adding branch
2067 + */
2068 +static int au_br_init_wh(struct super_block *sb, struct au_branch *br,
2069 +                        int new_perm, struct dentry *h_root)
2070 +{
2071 +       int err, old_perm;
2072 +       aufs_bindex_t bindex;
2073 +       struct mutex *h_mtx;
2074 +       struct au_wbr *wbr;
2075 +       struct au_hinode *hdir;
2076 +
2077 +       wbr = br->br_wbr;
2078 +       old_perm = br->br_perm;
2079 +       br->br_perm = new_perm;
2080 +       hdir = NULL;
2081 +       h_mtx = NULL;
2082 +       bindex = au_br_index(sb, br->br_id);
2083 +       if (0 <= bindex) {
2084 +               hdir = au_hi(sb->s_root->d_inode, bindex);
2085 +               au_hin_imtx_lock_nested(hdir, AuLsc_I_PARENT);
2086 +       } else {
2087 +               h_mtx = &h_root->d_inode->i_mutex;
2088 +               mutex_lock_nested(h_mtx, AuLsc_I_PARENT);
2089 +       }
2090 +       if (!wbr)
2091 +               err = au_wh_init(h_root, br, sb);
2092 +       else {
2093 +               wbr_wh_write_lock(wbr);
2094 +               err = au_wh_init(h_root, br, sb);
2095 +               wbr_wh_write_unlock(wbr);
2096 +       }
2097 +       if (hdir)
2098 +               au_hin_imtx_unlock(hdir);
2099 +       else
2100 +               mutex_unlock(h_mtx);
2101 +       br->br_perm = old_perm;
2102 +
2103 +       if (!err && wbr && !au_br_writable(new_perm)) {
2104 +               kfree(wbr);
2105 +               br->br_wbr = NULL;
2106 +       }
2107 +
2108 +       return err;
2109 +}
2110 +
2111 +static int au_wbr_init(struct au_branch *br, struct super_block *sb,
2112 +                      int perm, struct path *path)
2113 +{
2114 +       int err;
2115 +       struct kstatfs kst;
2116 +       struct au_wbr *wbr;
2117 +       struct dentry *h_dentry;
2118 +
2119 +       wbr = br->br_wbr;
2120 +       au_rw_init(&wbr->wbr_wh_rwsem);
2121 +       memset(wbr->wbr_wh, 0, sizeof(wbr->wbr_wh));
2122 +       atomic_set(&wbr->wbr_wh_running, 0);
2123 +       wbr->wbr_bytes = 0;
2124 +
2125 +       /*
2126 +        * a limit for rmdir/rename a dir
2127 +        * cf. AUFS_MAX_NAMELEN in include/linux/aufs_type.h
2128 +        */
2129 +       h_dentry = path->dentry;
2130 +       err = vfs_statfs(h_dentry, &kst);
2131 +       if (unlikely(err))
2132 +               goto out;
2133 +       err = -EINVAL;
2134 +       if (kst.f_namelen >= NAME_MAX)
2135 +               err = au_br_init_wh(sb, br, perm, h_dentry);
2136 +       else
2137 +               AuErr("%.*s(%s), unsupported namelen %ld\n",
2138 +                     AuDLNPair(h_dentry), au_sbtype(h_dentry->d_sb),
2139 +                     kst.f_namelen);
2140 +
2141 + out:
2142 +       return err;
2143 +}
2144 +
2145 +/* intialize a new branch */
2146 +static int au_br_init(struct au_branch *br, struct super_block *sb,
2147 +                     struct au_opt_add *add)
2148 +{
2149 +       int err;
2150 +
2151 +       err = 0;
2152 +       memset(&br->br_xino, 0, sizeof(br->br_xino));
2153 +       mutex_init(&br->br_xino.xi_nondir_mtx);
2154 +       br->br_perm = add->perm;
2155 +       br->br_mnt = add->path.mnt; /* set first, mntget() later */
2156 +       atomic_set(&br->br_count, 0);
2157 +       br->br_xino_upper = AUFS_XINO_TRUNC_INIT;
2158 +       atomic_set(&br->br_xino_running, 0);
2159 +       br->br_id = au_new_br_id(sb);
2160 +
2161 +       if (au_br_writable(add->perm)) {
2162 +               err = au_wbr_init(br, sb, add->perm, &add->path);
2163 +               if (unlikely(err))
2164 +                       goto out;
2165 +       }
2166 +
2167 +       if (au_opt_test(au_mntflags(sb), XINO)) {
2168 +               err = au_xino_br(sb, br, add->path.dentry->d_inode->i_ino,
2169 +                                au_sbr(sb, 0)->br_xino.xi_file, /*do_test*/1);
2170 +               if (unlikely(err)) {
2171 +                       AuDebugOn(br->br_xino.xi_file);
2172 +                       goto out;
2173 +               }
2174 +       }
2175 +
2176 +       sysaufs_br_init(br);
2177 +       mntget(add->path.mnt);
2178 +
2179 + out:
2180 +       return err;
2181 +}
2182 +
2183 +static void au_br_do_add_brp(struct au_sbinfo *sbinfo, aufs_bindex_t bindex,
2184 +                            struct au_branch *br, aufs_bindex_t bend,
2185 +                            aufs_bindex_t amount)
2186 +{
2187 +       struct au_branch **brp;
2188 +
2189 +       AuRwMustWriteLock(&sbinfo->si_rwsem);
2190 +
2191 +       brp = sbinfo->si_branch + bindex;
2192 +       memmove(brp + 1, brp, sizeof(*brp) * amount);
2193 +       *brp = br;
2194 +       sbinfo->si_bend++;
2195 +       if (unlikely(bend < 0))
2196 +               sbinfo->si_bend = 0;
2197 +}
2198 +
2199 +static void au_br_do_add_hdp(struct au_dinfo *dinfo, aufs_bindex_t bindex,
2200 +                            aufs_bindex_t bend, aufs_bindex_t amount)
2201 +{
2202 +       struct au_hdentry *hdp;
2203 +
2204 +       AuRwMustWriteLock(&dinfo->di_rwsem);
2205 +
2206 +       hdp = dinfo->di_hdentry + bindex;
2207 +       memmove(hdp + 1, hdp, sizeof(*hdp) * amount);
2208 +       au_h_dentry_init(hdp);
2209 +       dinfo->di_bend++;
2210 +       if (unlikely(bend < 0))
2211 +               dinfo->di_bstart = 0;
2212 +}
2213 +
2214 +static void au_br_do_add_hip(struct au_iinfo *iinfo, aufs_bindex_t bindex,
2215 +                            aufs_bindex_t bend, aufs_bindex_t amount)
2216 +{
2217 +       struct au_hinode *hip;
2218 +
2219 +       AuRwMustWriteLock(&iinfo->ii_rwsem);
2220 +
2221 +       hip = iinfo->ii_hinode + bindex;
2222 +       memmove(hip + 1, hip, sizeof(*hip) * amount);
2223 +       hip->hi_inode = NULL;
2224 +       au_hin_init(hip, NULL);
2225 +       iinfo->ii_bend++;
2226 +       if (unlikely(bend < 0))
2227 +               iinfo->ii_bstart = 0;
2228 +}
2229 +
2230 +static void au_br_do_add(struct super_block *sb, struct dentry *h_dentry,
2231 +                        struct au_branch *br, aufs_bindex_t bindex)
2232 +{
2233 +       struct dentry *root;
2234 +       struct inode *root_inode;
2235 +       aufs_bindex_t bend, amount;
2236 +
2237 +       root = sb->s_root;
2238 +       root_inode = root->d_inode;
2239 +       au_plink_maint_block(sb);
2240 +       bend = au_sbend(sb);
2241 +       amount = bend + 1 - bindex;
2242 +       au_br_do_add_brp(au_sbi(sb), bindex, br, bend, amount);
2243 +       au_br_do_add_hdp(au_di(root), bindex, bend, amount);
2244 +       au_br_do_add_hip(au_ii(root_inode), bindex, bend, amount);
2245 +       au_set_h_dptr(root, bindex, dget(h_dentry));
2246 +       au_set_h_iptr(root_inode, bindex, au_igrab(h_dentry->d_inode),
2247 +                     /*flags*/0);
2248 +}
2249 +
2250 +int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount)
2251 +{
2252 +       int err;
2253 +       aufs_bindex_t bend, add_bindex;
2254 +       struct dentry *root, *h_dentry;
2255 +       struct inode *root_inode;
2256 +       struct au_branch *add_branch;
2257 +
2258 +       root = sb->s_root;
2259 +       root_inode = root->d_inode;
2260 +       IMustLock(root_inode);
2261 +       err = test_add(sb, add, remount);
2262 +       if (unlikely(err < 0))
2263 +               goto out;
2264 +       if (err) {
2265 +               err = 0;
2266 +               goto out; /* success */
2267 +       }
2268 +
2269 +       bend = au_sbend(sb);
2270 +       add_branch = au_br_alloc(sb, bend + 2, add->perm);
2271 +       err = PTR_ERR(add_branch);
2272 +       if (IS_ERR(add_branch))
2273 +               goto out;
2274 +
2275 +       err = au_br_init(add_branch, sb, add);
2276 +       if (unlikely(err)) {
2277 +               au_br_do_free(add_branch);
2278 +               goto out;
2279 +       }
2280 +
2281 +       add_bindex = add->bindex;
2282 +       h_dentry = add->path.dentry;
2283 +       if (!remount)
2284 +               au_br_do_add(sb, h_dentry, add_branch, add_bindex);
2285 +       else {
2286 +               sysaufs_brs_del(sb, add_bindex);
2287 +               au_br_do_add(sb, h_dentry, add_branch, add_bindex);
2288 +               sysaufs_brs_add(sb, add_bindex);
2289 +       }
2290 +
2291 +       if (!add_bindex) {
2292 +               au_cpup_attr_all(root_inode, /*force*/1);
2293 +               sb->s_maxbytes = h_dentry->d_sb->s_maxbytes;
2294 +       } else
2295 +               au_add_nlink(root_inode, h_dentry->d_inode);
2296 +
2297 +       /*
2298 +        * this test/set prevents aufs from handling unnecesary inotify events
2299 +        * of xino files, in a case of re-adding a writable branch which was
2300 +        * once detached from aufs.
2301 +        */
2302 +       if (au_xino_brid(sb) < 0
2303 +           && au_br_writable(add_branch->br_perm)
2304 +           && !au_test_fs_bad_xino(h_dentry->d_sb)
2305 +           && add_branch->br_xino.xi_file
2306 +           && add_branch->br_xino.xi_file->f_dentry->d_parent == h_dentry)
2307 +               au_xino_brid_set(sb, add_branch->br_id);
2308 +
2309 + out:
2310 +       return err;
2311 +}
2312 +
2313 +/* ---------------------------------------------------------------------- */
2314 +
2315 +/*
2316 + * delete a branch
2317 + */
2318 +
2319 +/* to show the line number, do not make it inlined function */
2320 +#define AuVerbose(do_info, fmt, ...) do { \
2321 +       if (do_info) \
2322 +               AuInfo(fmt, ##__VA_ARGS__); \
2323 +} while (0)
2324 +
2325 +/*
2326 + * test if the branch is deletable or not.
2327 + */
2328 +static int test_dentry_busy(struct dentry *root, aufs_bindex_t bindex,
2329 +                           unsigned int sigen)
2330 +{
2331 +       int err, i, j, ndentry;
2332 +       aufs_bindex_t bstart, bend;
2333 +       unsigned char verbose;
2334 +       struct au_dcsub_pages dpages;
2335 +       struct au_dpage *dpage;
2336 +       struct dentry *d;
2337 +       struct inode *inode;
2338 +
2339 +       err = au_dpages_init(&dpages, GFP_NOFS);
2340 +       if (unlikely(err))
2341 +               goto out;
2342 +       err = au_dcsub_pages(&dpages, root, NULL, NULL);
2343 +       if (unlikely(err))
2344 +               goto out_dpages;
2345 +
2346 +       verbose = !!au_opt_test(au_mntflags(root->d_sb), VERBOSE);
2347 +       for (i = 0; !err && i < dpages.ndpage; i++) {
2348 +               dpage = dpages.dpages + i;
2349 +               ndentry = dpage->ndentry;
2350 +               for (j = 0; !err && j < ndentry; j++) {
2351 +                       d = dpage->dentries[j];
2352 +                       AuDebugOn(!atomic_read(&d->d_count));
2353 +                       inode = d->d_inode;
2354 +                       if (au_digen(d) == sigen && au_iigen(inode) == sigen)
2355 +                               di_read_lock_child(d, AuLock_IR);
2356 +                       else {
2357 +                               di_write_lock_child(d);
2358 +                               err = au_reval_dpath(d, sigen);
2359 +                               if (!err)
2360 +                                       di_downgrade_lock(d, AuLock_IR);
2361 +                               else {
2362 +                                       di_write_unlock(d);
2363 +                                       break;
2364 +                               }
2365 +                       }
2366 +
2367 +                       bstart = au_dbstart(d);
2368 +                       bend = au_dbend(d);
2369 +                       if (bstart <= bindex
2370 +                           && bindex <= bend
2371 +                           && au_h_dptr(d, bindex)
2372 +                           && (!S_ISDIR(inode->i_mode) || bstart == bend)) {
2373 +                               err = -EBUSY;
2374 +                               AuVerbose(verbose, "busy %.*s\n", AuDLNPair(d));
2375 +                       }
2376 +                       di_read_unlock(d, AuLock_IR);
2377 +               }
2378 +       }
2379 +
2380 + out_dpages:
2381 +       au_dpages_free(&dpages);
2382 + out:
2383 +       return err;
2384 +}
2385 +
2386 +static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex,
2387 +                          unsigned int sigen)
2388 +{
2389 +       int err;
2390 +       struct inode *i;
2391 +       aufs_bindex_t bstart, bend;
2392 +       unsigned char verbose;
2393 +
2394 +       err = 0;
2395 +       verbose = !!au_opt_test(au_mntflags(sb), VERBOSE);
2396 +       list_for_each_entry(i, &sb->s_inodes, i_sb_list) {
2397 +               AuDebugOn(!atomic_read(&i->i_count));
2398 +               if (!list_empty(&i->i_dentry))
2399 +                       continue;
2400 +
2401 +               if (au_iigen(i) == sigen)
2402 +                       ii_read_lock_child(i);
2403 +               else {
2404 +                       ii_write_lock_child(i);
2405 +                       err = au_refresh_hinode_self(i, /*do_attr*/1);
2406 +                       if (!err)
2407 +                               ii_downgrade_lock(i);
2408 +                       else {
2409 +                               ii_write_unlock(i);
2410 +                               break;
2411 +                       }
2412 +               }
2413 +
2414 +               bstart = au_ibstart(i);
2415 +               bend = au_ibend(i);
2416 +               if (bstart <= bindex
2417 +                   && bindex <= bend
2418 +                   && au_h_iptr(i, bindex)
2419 +                   && (!S_ISDIR(i->i_mode) || bstart == bend)) {
2420 +                       err = -EBUSY;
2421 +                       AuVerbose(verbose, "busy i%lu\n", i->i_ino);
2422 +                       ii_read_unlock(i);
2423 +                       break;
2424 +               }
2425 +               ii_read_unlock(i);
2426 +       }
2427 +
2428 +       return err;
2429 +}
2430 +
2431 +static int test_children_busy(struct dentry *root, aufs_bindex_t bindex)
2432 +{
2433 +       int err;
2434 +       unsigned int sigen;
2435 +
2436 +       sigen = au_sigen(root->d_sb);
2437 +       DiMustNoWaiters(root);
2438 +       IiMustNoWaiters(root->d_inode);
2439 +       di_write_unlock(root);
2440 +       err = test_dentry_busy(root, bindex, sigen);
2441 +       if (!err)
2442 +               err = test_inode_busy(root->d_sb, bindex, sigen);
2443 +       di_write_lock_child(root); /* aufs_write_lock() calls ..._child() */
2444 +
2445 +       return err;
2446 +}
2447 +
2448 +static void au_br_do_del_brp(struct au_sbinfo *sbinfo,
2449 +                            const aufs_bindex_t bindex,
2450 +                            const aufs_bindex_t bend)
2451 +{
2452 +       struct au_branch **brp, **p;
2453 +
2454 +       AuRwMustWriteLock(&sbinfo->si_rwsem);
2455 +
2456 +       brp = sbinfo->si_branch + bindex;
2457 +       if (bindex < bend)
2458 +               memmove(brp, brp + 1, sizeof(*brp) * (bend - bindex));
2459 +       sbinfo->si_branch[0 + bend] = NULL;
2460 +       sbinfo->si_bend--;
2461 +
2462 +       p = krealloc(sbinfo->si_branch, sizeof(*p) * bend, GFP_NOFS);
2463 +       if (p)
2464 +               sbinfo->si_branch = p;
2465 +}
2466 +
2467 +static void au_br_do_del_hdp(struct au_dinfo *dinfo, const aufs_bindex_t bindex,
2468 +                            const aufs_bindex_t bend)
2469 +{
2470 +       struct au_hdentry *hdp, *p;
2471 +
2472 +       AuRwMustWriteLock(&dinfo->di_rwsem);
2473 +
2474 +       hdp = dinfo->di_hdentry + bindex;
2475 +       if (bindex < bend)
2476 +               memmove(hdp, hdp + 1, sizeof(*hdp) * (bend - bindex));
2477 +       dinfo->di_hdentry[0 + bend].hd_dentry = NULL;
2478 +       dinfo->di_bend--;
2479 +
2480 +       p = krealloc(dinfo->di_hdentry, sizeof(*p) * bend, GFP_NOFS);
2481 +       if (p)
2482 +               dinfo->di_hdentry = p;
2483 +}
2484 +
2485 +static void au_br_do_del_hip(struct au_iinfo *iinfo, const aufs_bindex_t bindex,
2486 +                            const aufs_bindex_t bend)
2487 +{
2488 +       struct au_hinode *hip, *p;
2489 +
2490 +       AuRwMustWriteLock(&iinfo->ii_rwsem);
2491 +
2492 +       hip = iinfo->ii_hinode + bindex;
2493 +       if (bindex < bend)
2494 +               memmove(hip, hip + 1, sizeof(*hip) * (bend - bindex));
2495 +       iinfo->ii_hinode[0 + bend].hi_inode = NULL;
2496 +       au_hin_init(iinfo->ii_hinode + bend, NULL);
2497 +       iinfo->ii_bend--;
2498 +
2499 +       p = krealloc(iinfo->ii_hinode, sizeof(*p) * bend, GFP_NOFS);
2500 +       if (p)
2501 +               iinfo->ii_hinode = p;
2502 +}
2503 +
2504 +static void au_br_do_del(struct super_block *sb, aufs_bindex_t bindex,
2505 +                        struct au_branch *br)
2506 +{
2507 +       aufs_bindex_t bend;
2508 +       struct au_sbinfo *sbinfo;
2509 +       struct dentry *root;
2510 +       struct inode *inode;
2511 +
2512 +       SiMustWriteLock(sb);
2513 +
2514 +       root = sb->s_root;
2515 +       inode = root->d_inode;
2516 +       au_plink_maint_block(sb);
2517 +       sbinfo = au_sbi(sb);
2518 +       bend = sbinfo->si_bend;
2519 +
2520 +       dput(au_h_dptr(root, bindex));
2521 +       au_hiput(au_hi(inode, bindex));
2522 +       au_br_do_free(br);
2523 +
2524 +       au_br_do_del_brp(sbinfo, bindex, bend);
2525 +       au_br_do_del_hdp(au_di(root), bindex, bend);
2526 +       au_br_do_del_hip(au_ii(inode), bindex, bend);
2527 +}
2528 +
2529 +int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount)
2530 +{
2531 +       int err, rerr, i;
2532 +       unsigned int mnt_flags;
2533 +       aufs_bindex_t bindex, bend, br_id;
2534 +       unsigned char do_wh, verbose;
2535 +       struct au_branch *br;
2536 +       struct au_wbr *wbr;
2537 +
2538 +       err = 0;
2539 +       bindex = au_find_dbindex(sb->s_root, del->h_path.dentry);
2540 +       if (bindex < 0) {
2541 +               if (remount)
2542 +                       goto out; /* success */
2543 +               err = -ENOENT;
2544 +               AuErr("%s no such branch\n", del->pathname);
2545 +               goto out;
2546 +       }
2547 +       AuDbg("bindex b%d\n", bindex);
2548 +
2549 +       err = -EBUSY;
2550 +       mnt_flags = au_mntflags(sb);
2551 +       verbose = !!au_opt_test(mnt_flags, VERBOSE);
2552 +       bend = au_sbend(sb);
2553 +       if (unlikely(!bend)) {
2554 +               AuVerbose(verbose, "no more branches left\n");
2555 +               goto out;
2556 +       }
2557 +       br = au_sbr(sb, bindex);
2558 +       i = atomic_read(&br->br_count);
2559 +       if (unlikely(i)) {
2560 +               AuVerbose(verbose, "%d file(s) opened\n", i);
2561 +               goto out;
2562 +       }
2563 +
2564 +       wbr = br->br_wbr;
2565 +       do_wh = wbr && (wbr->wbr_whbase || wbr->wbr_plink || wbr->wbr_orph);
2566 +       if (do_wh) {
2567 +               /* instead of WbrWhMustWriteLock(wbr) */
2568 +               SiMustWriteLock(sb);
2569 +               for (i = 0; i < AuBrWh_Last; i++) {
2570 +                       dput(wbr->wbr_wh[i]);
2571 +                       wbr->wbr_wh[i] = NULL;
2572 +               }
2573 +       }
2574 +
2575 +       err = test_children_busy(sb->s_root, bindex);
2576 +       if (unlikely(err)) {
2577 +               if (do_wh)
2578 +                       goto out_wh;
2579 +               goto out;
2580 +       }
2581 +
2582 +       err = 0;
2583 +       br_id = br->br_id;
2584 +       if (!remount)
2585 +               au_br_do_del(sb, bindex, br);
2586 +       else {
2587 +               sysaufs_brs_del(sb, bindex);
2588 +               au_br_do_del(sb, bindex, br);
2589 +               sysaufs_brs_add(sb, bindex);
2590 +       }
2591 +
2592 +       if (!bindex) {
2593 +               au_cpup_attr_all(sb->s_root->d_inode, /*force*/1);
2594 +               sb->s_maxbytes = au_sbr_sb(sb, 0)->s_maxbytes;
2595 +       } else
2596 +               au_sub_nlink(sb->s_root->d_inode, del->h_path.dentry->d_inode);
2597 +       if (au_opt_test(mnt_flags, PLINK))
2598 +               au_plink_half_refresh(sb, br_id);
2599 +
2600 +       if (au_xino_brid(sb) == br->br_id)
2601 +               au_xino_brid_set(sb, -1);
2602 +       goto out; /* success */
2603 +
2604 + out_wh:
2605 +       /* revert */
2606 +       rerr = au_br_init_wh(sb, br, br->br_perm, del->h_path.dentry);
2607 +       if (rerr)
2608 +               AuWarn("failed re-creating base whiteout, %s. (%d)\n",
2609 +                      del->pathname, rerr);
2610 + out:
2611 +       return err;
2612 +}
2613 +
2614 +/* ---------------------------------------------------------------------- */
2615 +
2616 +/*
2617 + * change a branch permission
2618 + */
2619 +
2620 +static int do_need_sigen_inc(int a, int b)
2621 +{
2622 +       return au_br_whable(a) && !au_br_whable(b);
2623 +}
2624 +
2625 +static int need_sigen_inc(int old, int new)
2626 +{
2627 +       return do_need_sigen_inc(old, new)
2628 +               || do_need_sigen_inc(new, old);
2629 +}
2630 +
2631 +static int au_br_mod_files_ro(struct super_block *sb, aufs_bindex_t bindex)
2632 +{
2633 +       int err;
2634 +       unsigned long n, ul, bytes, files;
2635 +       aufs_bindex_t bstart;
2636 +       struct file *file, *hf, **a;
2637 +       const int step_bytes = 1024, /* memory allocation unit */
2638 +               step_files = step_bytes / sizeof(*a);
2639 +
2640 +       err = -ENOMEM;
2641 +       n = 0;
2642 +       bytes = step_bytes;
2643 +       files = step_files;
2644 +       a = kmalloc(bytes, GFP_NOFS);
2645 +       if (unlikely(!a))
2646 +               goto out;
2647 +
2648 +       /* no need file_list_lock() since sbinfo is locked? defered? */
2649 +       list_for_each_entry(file, &sb->s_files, f_u.fu_list) {
2650 +               if (special_file(file->f_dentry->d_inode->i_mode))
2651 +                       continue;
2652 +
2653 +               AuDbg("%.*s\n", AuDLNPair(file->f_dentry));
2654 +               fi_read_lock(file);
2655 +               if (unlikely(au_test_mmapped(file))) {
2656 +                       err = -EBUSY;
2657 +                       FiMustNoWaiters(file);
2658 +                       fi_read_unlock(file);
2659 +                       goto out_free;
2660 +               }
2661 +
2662 +               bstart = au_fbstart(file);
2663 +               if (!S_ISREG(file->f_dentry->d_inode->i_mode)
2664 +                   || !(file->f_mode & FMODE_WRITE)
2665 +                   || bstart != bindex) {
2666 +                       FiMustNoWaiters(file);
2667 +                       fi_read_unlock(file);
2668 +                       continue;
2669 +               }
2670 +
2671 +               hf = au_h_fptr(file, bstart);
2672 +               FiMustNoWaiters(file);
2673 +               fi_read_unlock(file);
2674 +
2675 +               if (n < files)
2676 +                       a[n++] = hf;
2677 +               else {
2678 +                       void *p;
2679 +
2680 +                       err = -ENOMEM;
2681 +                       bytes += step_bytes;
2682 +                       files += step_files;
2683 +                       p = krealloc(a, bytes, GFP_NOFS);
2684 +                       if (p) {
2685 +                               a = p;
2686 +                               a[n++] = hf;
2687 +                       } else
2688 +                               goto out_free;
2689 +               }
2690 +       }
2691 +
2692 +       err = 0;
2693 +       for (ul = 0; ul < n; ul++) {
2694 +               /* todo: already flushed? */
2695 +               /* cf. fs/super.c:mark_files_ro() */
2696 +               hf = a[ul];
2697 +               hf->f_mode &= ~FMODE_WRITE;
2698 +               if (!file_check_writeable(hf)) {
2699 +                       file_release_write(hf);
2700 +                       mnt_drop_write(hf->f_vfsmnt);
2701 +               }
2702 +       }
2703 +
2704 + out_free:
2705 +       kfree(a);
2706 + out:
2707 +       return err;
2708 +}
2709 +
2710 +int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount,
2711 +             int *do_update)
2712 +{
2713 +       int err, rerr;
2714 +       aufs_bindex_t bindex;
2715 +       struct path path;
2716 +       struct dentry *root;
2717 +       struct au_branch *br;
2718 +
2719 +       root = sb->s_root;
2720 +       au_plink_maint_block(sb);
2721 +       bindex = au_find_dbindex(root, mod->h_root);
2722 +       if (bindex < 0) {
2723 +               if (remount)
2724 +                       return 0; /* success */
2725 +               err = -ENOENT;
2726 +               AuErr("%s no such branch\n", mod->path);
2727 +               goto out;
2728 +       }
2729 +       AuDbg("bindex b%d\n", bindex);
2730 +
2731 +       err = test_br(mod->h_root->d_inode, mod->perm, mod->path);
2732 +       if (unlikely(err))
2733 +               goto out;
2734 +
2735 +       br = au_sbr(sb, bindex);
2736 +       if (br->br_perm == mod->perm)
2737 +               return 0; /* success */
2738 +
2739 +       if (au_br_writable(br->br_perm)) {
2740 +               /* remove whiteout base */
2741 +               err = au_br_init_wh(sb, br, mod->perm, mod->h_root);
2742 +               if (unlikely(err))
2743 +                       goto out;
2744 +
2745 +               if (!au_br_writable(mod->perm)) {
2746 +                       /* rw --> ro, file might be mmapped */
2747 +                       DiMustNoWaiters(root);
2748 +                       IiMustNoWaiters(root->d_inode);
2749 +                       di_write_unlock(root);
2750 +                       err = au_br_mod_files_ro(sb, bindex);
2751 +                       /* aufs_write_lock() calls ..._child() */
2752 +                       di_write_lock_child(root);
2753 +
2754 +                       if (unlikely(err)) {
2755 +                               rerr = -ENOMEM;
2756 +                               br->br_wbr = kmalloc(sizeof(*br->br_wbr),
2757 +                                                    GFP_NOFS);
2758 +                               if (br->br_wbr) {
2759 +                                       path.mnt = br->br_mnt;
2760 +                                       path.dentry = mod->h_root;
2761 +                                       rerr = au_wbr_init(br, sb, br->br_perm,
2762 +                                                          &path);
2763 +                               }
2764 +                               if (unlikely(rerr)) {
2765 +                                       AuIOErr("nested error %d (%d)\n",
2766 +                                               rerr, err);
2767 +                                       br->br_perm = mod->perm;
2768 +                               }
2769 +                       }
2770 +               }
2771 +       } else if (au_br_writable(mod->perm)) {
2772 +               /* ro --> rw */
2773 +               err = -ENOMEM;
2774 +               br->br_wbr = kmalloc(sizeof(*br->br_wbr), GFP_NOFS);
2775 +               if (br->br_wbr) {
2776 +                       path.mnt = br->br_mnt;
2777 +                       path.dentry = mod->h_root;
2778 +                       err = au_wbr_init(br, sb, mod->perm, &path);
2779 +                       if (unlikely(err)) {
2780 +                               kfree(br->br_wbr);
2781 +                               br->br_wbr = NULL;
2782 +                       }
2783 +               }
2784 +       }
2785 +
2786 +       if (!err) {
2787 +               *do_update |= need_sigen_inc(br->br_perm, mod->perm);
2788 +               br->br_perm = mod->perm;
2789 +       }
2790 +
2791 + out:
2792 +       return err;
2793 +}
2794 diff --git a/fs/aufs/branch.h b/fs/aufs/branch.h
2795 new file mode 100644
2796 index 0000000..1a7219c
2797 --- /dev/null
2798 +++ b/fs/aufs/branch.h
2799 @@ -0,0 +1,219 @@
2800 +/*
2801 + * Copyright (C) 2005-2009 Junjiro R. Okajima
2802 + *
2803 + * This program, aufs is free software; you can redistribute it and/or modify
2804 + * it under the terms of the GNU General Public License as published by
2805 + * the Free Software Foundation; either version 2 of the License, or
2806 + * (at your option) any later version.
2807 + *
2808 + * This program is distributed in the hope that it will be useful,
2809 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2810 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2811 + * GNU General Public License for more details.
2812 + *
2813 + * You should have received a copy of the GNU General Public License
2814 + * along with this program; if not, write to the Free Software
2815 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
2816 + */
2817 +
2818 +/*
2819 + * branch filesystems and xino for them
2820 + */
2821 +
2822 +#ifndef __AUFS_BRANCH_H__
2823 +#define __AUFS_BRANCH_H__
2824 +
2825 +#ifdef __KERNEL__
2826 +
2827 +#include <linux/fs.h>
2828 +#include <linux/mount.h>
2829 +#include <linux/aufs_type.h>
2830 +#include "rwsem.h"
2831 +#include "super.h"
2832 +
2833 +/* ---------------------------------------------------------------------- */
2834 +
2835 +/* a xino file */
2836 +struct au_xino_file {
2837 +       struct file             *xi_file;
2838 +       struct mutex            xi_nondir_mtx;
2839 +
2840 +       /* todo: make xino files an array to support huge inode number */
2841 +
2842 +#ifdef CONFIG_DEBUG_FS
2843 +       struct dentry            *xi_dbgaufs;
2844 +#endif
2845 +};
2846 +
2847 +/* members for writable branch only */
2848 +enum {AuBrWh_BASE, AuBrWh_PLINK, AuBrWh_ORPH, AuBrWh_Last};
2849 +struct au_wbr {
2850 +       struct au_rwsem         wbr_wh_rwsem;
2851 +       struct dentry           *wbr_wh[AuBrWh_Last];
2852 +       atomic_t                wbr_wh_running;
2853 +#define wbr_whbase             wbr_wh[AuBrWh_BASE]     /* whiteout base */
2854 +#define wbr_plink              wbr_wh[AuBrWh_PLINK]    /* pseudo-link dir */
2855 +#define wbr_orph               wbr_wh[AuBrWh_ORPH]     /* dir for orphans */
2856 +
2857 +       /* mfs mode */
2858 +       unsigned long long      wbr_bytes;
2859 +};
2860 +
2861 +/* protected by superblock rwsem */
2862 +struct au_branch {
2863 +       struct au_xino_file     br_xino;
2864 +
2865 +       aufs_bindex_t           br_id;
2866 +
2867 +       int                     br_perm;
2868 +       struct vfsmount         *br_mnt;
2869 +       atomic_t                br_count;
2870 +
2871 +       struct au_wbr           *br_wbr;
2872 +
2873 +       /* xino truncation */
2874 +       blkcnt_t                br_xino_upper;  /* watermark in blocks */
2875 +       atomic_t                br_xino_running;
2876 +
2877 +#ifdef CONFIG_SYSFS
2878 +       /* an entry under sysfs per mount-point */
2879 +       char                    br_name[8];
2880 +       struct attribute        br_attr;
2881 +#endif
2882 +};
2883 +
2884 +/* ---------------------------------------------------------------------- */
2885 +
2886 +/* branch permission and attribute */
2887 +enum {
2888 +       AuBrPerm_RW,            /* writable, linkable wh */
2889 +       AuBrPerm_RO,            /* readonly, no wh */
2890 +       AuBrPerm_RR,            /* natively readonly, no wh */
2891 +
2892 +       AuBrPerm_RWNoLinkWH,    /* un-linkable whiteouts */
2893 +
2894 +       AuBrPerm_ROWH,          /* whiteout-able */
2895 +       AuBrPerm_RRWH,          /* whiteout-able */
2896 +
2897 +       AuBrPerm_Last
2898 +};
2899 +
2900 +static inline int au_br_writable(int brperm)
2901 +{
2902 +       return brperm == AuBrPerm_RW || brperm == AuBrPerm_RWNoLinkWH;
2903 +}
2904 +
2905 +static inline int au_br_whable(int brperm)
2906 +{