projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ppp: fix fallout from the size reduction patch (thx, frogonwheels)
[openwrt/svn-archive/archive.git] / target / linux / generic / patches-2.6.38 / 209-overlayfs.patch
1 --- /dev/null
2 +++ b/Documentation/filesystems/overlayfs.txt
3 @@ -0,0 +1,163 @@
4 +Written by: Neil Brown <neilb@suse.de>
5 +
6 +Overlay Filesystem
7 +==================
8 +
9 +This document describes a prototype for a new approach to providing
10 +overlay-filesystem functionality in Linux (sometimes referred to as
11 +union-filesystems). An overlay-filesystem tries to present a
12 +filesystem which is the result over overlaying one filesystem on top
13 +of the other.
14 +
15 +The result will inevitably fail to look exactly like a normal
16 +filesystem for various technical reasons. The expectation is that
17 +many use cases will be able to ignore these differences.
18 +
19 +This approach is 'hybrid' because the objects that appear in the
20 +filesystem do not all appear to belong to that filesystem. In many
21 +case an object accessed in the union will be indistinguishable
22 +from accessing the corresponding object from the original filesystem.
23 +This is most obvious from the 'st_dev' field returned by stat(2).
24 +
25 +While directories will report an st_dev for the overlay-filesystem,
26 +all non-directory objects will report an st_dev whichever of the
27 +'lower' or 'upper' filesystem that is providing the object. Similarly
28 +st_ino will only be unique when combined with st_dev, and both of
29 +these can change over the lifetime of a non-directory object. Many
30 +applications and tools ignore these values and will not be affected.
31 +
32 +Upper and Lower
33 +---------------
34 +
35 +An overlay filesystem combines two filesystems - an 'upper' filesystem
36 +and a 'lower' filesystem. When a name exists in both filesystems, the
37 +object in the 'upper' filesystem is visible while the object in the
38 +'lower' filesystem is either hidden or, in the case of directories,
39 +merged with the 'upper' object.
40 +
41 +It would be more correct to refer to an upper and lower 'directory
42 +tree' rather than 'filesystem' as it is quite possible for both
43 +directory trees to be in the same filesystem and there is no
44 +requirement that the root of a filesystem be given for either upper or
45 +lower.
46 +
47 +The lower filesystem can be any filesystem supported by Linux and does
48 +not need to be writable. The lower filesystem can even be another
49 +overlayfs. The upper filesystem will normally be writable and if it
50 +is it must support the creation of trusted.* extended attributes, and
51 +must provide valid d_type in readdir responses, at least for symbolic
52 +links - so NFS is not suitable.
53 +
54 +A read-only overlay of two read-only filesystems may use any
55 +filesystem type.
56 +
57 +Directories
58 +-----------
59 +
60 +Overlaying mainly involved directories. If a given name appears in both
61 +upper and lower filesystems and refers to a non-directory in either,
62 +then the lower object is hidden - the name refers only to the upper
63 +object.
64 +
65 +Where both upper and lower objects are directories, a merged directory
66 +is formed.
67 +
68 +At mount time, the two directories given as mount options are combined
69 +into a merged directory. Then whenever a lookup is requested in such
70 +a merged directory, the lookup is performed in each actual directory
71 +and the combined result is cached in the dentry belonging to the overlay
72 +filesystem. If both actual lookups find directories, both are stored
73 +and a merged directory is created, otherwise only one is stored: the
74 +upper if it exists, else the lower.
75 +
76 +Only the lists of names from directories are merged. Other content
77 +such as metadata and extended attributes are reported for the upper
78 +directory only. These attributes of the lower directory are hidden.
79 +
80 +whiteouts and opaque directories
81 +--------------------------------
82 +
83 +In order to support rm and rmdir without changing the lower
84 +filesystem, an overlay filesystem needs to record in the upper filesystem
85 +that files have been removed. This is done using whiteouts and opaque
86 +directories (non-directories are always opaque).
87 +
88 +The overlay filesystem uses extended attributes with a
89 +"trusted.overlay." prefix to record these details.
90 +
91 +A whiteout is created as a symbolic link with target
92 +"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y".
93 +When a whiteout is found in the upper level of a merged directory, any
94 +matching name in the lower level is ignored, and the whiteout itself
95 +is also hidden.
96 +
97 +A directory is made opaque by setting the xattr "trusted.overlay.opaque"
98 +to "y". Where the upper filesystem contains an opaque directory, any
99 +directory in the lower filesystem with the same name is ignored.
100 +
101 +readdir
102 +-------
103 +
104 +When a 'readdir' request is made on a merged directory, the upper and
105 +lower directories are each read and the name lists merged in the
106 +obvious way (upper is read first, then lower - entries that already
107 +exist are not re-added). This merged name list is cached in the
108 +'struct file' and so remains as long as the file is kept open. If the
109 +directory is opened and read by two processes at the same time, they
110 +will each have separate caches. A seekdir to the start of the
111 +directory (offset 0) followed by a readdir will cause the cache to be
112 +discarded and rebuilt.
113 +
114 +This means that changes to the merged directory do not appear while a
115 +directory is being read. This is unlikely to be noticed by many
116 +programs.
117 +
118 +seek offsets are assigned sequentially when the directories are read.
119 +Thus if
120 + - read part of a directory
121 + - remember an offset, and close the directory
122 + - re-open the directory some time later
123 + - seek to the remembered offset
124 +
125 +there may be little correlation between the old and new locations in
126 +the list of filenames, particularly if anything has changed in the
127 +directory.
128 +
129 +Readdir on directories that are not merged is simply handled by the
130 +underlying directory (upper or lower).
131 +
132 +
133 +Non-directories
134 +---------------
135 +
136 +Objects that are not directories (files, symlinks, device-special
137 +files etc) are presented either from the upper or lower filesystem as
138 +appropriate. When a file in the lower filesystem is accessed in a way
139 +the requires write-access; such as opening for write access, changing
140 +some metadata etc, the file is first copied from the lower filesystem
141 +to the upper filesystem (copy_up). Note that creating a hard-link
142 +also requires copy-up, though of course creation of a symlink does
143 +not.
144 +
145 +The copy_up process first makes sure that the containing directory
146 +exists in the upper filesystem - creating it and any parents as
147 +necessary. It then creates the object with the same metadata (owner,
148 +mode, mtime, symlink-target etc) and then if the object is a file, the
149 +data is copied from the lower to the upper filesystem. Finally any
150 +extended attributes are copied up.
151 +
152 +Once the copy_up is complete, the overlay filesystem simply
153 +provides direct access to the newly created file in the upper
154 +filesystem - future operations on the file are barely noticed by the
155 +overlay filesystem (though an operation on the name of the file such as
156 +rename or unlink will of course be noticed and handled).
157 +
158 +Changes to underlying filesystems
159 +---------------------------------
160 +
161 +Offline changes, when the overlay is not mounted, are allowed to either
162 +the upper or the lower trees.
163 +
164 +Changes to the underlying filesystems while part of a mounted overlay
165 +filesystem are not allowed. This is not yet enforced, but will be in
166 +the future.
167 --- a/fs/Kconfig
168 +++ b/fs/Kconfig
169 @@ -63,6 +63,7 @@ source "fs/quota/Kconfig"
170
171 source "fs/autofs4/Kconfig"
172 source "fs/fuse/Kconfig"
173 +source "fs/overlayfs/Kconfig"
174
175 config CUSE
176 tristate "Character device in Userspace support"
177 --- a/fs/Makefile
178 +++ b/fs/Makefile
179 @@ -103,6 +103,7 @@ obj-$(CONFIG_QNX4FS_FS) += qnx4/
180 obj-$(CONFIG_AUTOFS4_FS) += autofs4/
181 obj-$(CONFIG_ADFS_FS) += adfs/
182 obj-$(CONFIG_FUSE_FS) += fuse/
183 +obj-$(CONFIG_OVERLAYFS_FS) += overlayfs/
184 obj-$(CONFIG_UDF_FS) += udf/
185 obj-$(CONFIG_SUN_OPENPROMFS) += openpromfs/
186 obj-$(CONFIG_OMFS_FS) += omfs/
187 --- a/fs/namespace.c
188 +++ b/fs/namespace.c
189 @@ -1451,6 +1451,23 @@ void drop_collected_mounts(struct vfsmou
190 release_mounts(&umount_list);
191 }
192
193 +struct vfsmount *clone_private_mount(struct path *path)
194 +{
195 + struct vfsmount *mnt;
196 +
197 + if (IS_MNT_UNBINDABLE(path->mnt))
198 + return ERR_PTR(-EINVAL);
199 +
200 + down_read(&namespace_sem);
201 + mnt = clone_mnt(path->mnt, path->dentry, CL_PRIVATE);
202 + up_read(&namespace_sem);
203 + if (!mnt)
204 + return ERR_PTR(-ENOMEM);
205 +
206 + return mnt;
207 +}
208 +EXPORT_SYMBOL_GPL(clone_private_mount);
209 +
210 int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
211 struct vfsmount *root)
212 {
213 --- a/fs/open.c
214 +++ b/fs/open.c
215 @@ -664,19 +664,19 @@ static inline int __get_file_write_acces
216 return error;
217 }
218
219 -static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
220 - struct file *f,
221 +static struct file *__dentry_open(struct path *path, struct file *f,
222 int (*open)(struct inode *, struct file *),
223 const struct cred *cred)
224 {
225 struct inode *inode;
226 int error;
227
228 + path_get(path);
229 f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
230 FMODE_PREAD | FMODE_PWRITE;
231 - inode = dentry->d_inode;
232 + inode = path->dentry->d_inode;
233 if (f->f_mode & FMODE_WRITE) {
234 - error = __get_file_write_access(inode, mnt);
235 + error = __get_file_write_access(inode, path->mnt);
236 if (error)
237 goto cleanup_file;
238 if (!special_file(inode->i_mode))
239 @@ -684,8 +684,7 @@ static struct file *__dentry_open(struct
240 }
241
242 f->f_mapping = inode->i_mapping;
243 - f->f_path.dentry = dentry;
244 - f->f_path.mnt = mnt;
245 + f->f_path = *path;
246 f->f_pos = 0;
247 f->f_op = fops_get(inode->i_fop);
248 file_sb_list_add(f, inode->i_sb);
249 @@ -731,7 +730,7 @@ cleanup_all:
250 * here, so just reset the state.
251 */
252 file_reset_write(f);
253 - mnt_drop_write(mnt);
254 + mnt_drop_write(path->mnt);
255 }
256 }
257 file_sb_list_del(f);
258 @@ -739,8 +738,7 @@ cleanup_all:
259 f->f_path.mnt = NULL;
260 cleanup_file:
261 put_filp(f);
262 - dput(dentry);
263 - mntput(mnt);
264 + path_put(path);
265 return ERR_PTR(error);
266 }
267
268 @@ -766,14 +764,14 @@ cleanup_file:
269 struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
270 int (*open)(struct inode *, struct file *))
271 {
272 + struct path path = { .dentry = dentry, .mnt = nd->path.mnt };
273 const struct cred *cred = current_cred();
274
275 if (IS_ERR(nd->intent.open.file))
276 goto out;
277 if (IS_ERR(dentry))
278 goto out_err;
279 - nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->path.mnt),
280 - nd->intent.open.file,
281 + nd->intent.open.file = __dentry_open(&path, nd->intent.open.file,
282 open, cred);
283 out:
284 return nd->intent.open.file;
285 @@ -802,10 +800,17 @@ struct file *nameidata_to_filp(struct na
286
287 /* Has the filesystem initialised the file for us? */
288 if (filp->f_path.dentry == NULL) {
289 - path_get(&nd->path);
290 - filp = __dentry_open(nd->path.dentry, nd->path.mnt, filp,
291 - NULL, cred);
292 + struct inode *inode = nd->path.dentry->d_inode;
293 +
294 + if (inode->i_op->open) {
295 + int flags = filp->f_flags;
296 + put_filp(filp);
297 + filp = inode->i_op->open(nd->path.dentry, flags, cred);
298 + } else {
299 + filp = __dentry_open(&nd->path, filp, NULL, cred);
300 + }
301 }
302 +
303 return filp;
304 }
305
306 @@ -816,35 +821,45 @@ struct file *nameidata_to_filp(struct na
307 struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags,
308 const struct cred *cred)
309 {
310 - int error;
311 + struct path path = { .dentry = dentry, .mnt = mnt };
312 + struct file *ret;
313 +
314 + BUG_ON(!mnt);
315 +
316 + ret = vfs_open(&path, flags, cred);
317 + path_put(&path);
318 +
319 + return ret;
320 +}
321 +EXPORT_SYMBOL(dentry_open);
322 +
323 +/**
324 + * vfs_open - open the file at the given path
325 + * @path: path to open
326 + * @flags: open flags
327 + * @cred: credentials to use
328 + *
329 + * Open the file. If successful, the returned file will have acquired
330 + * an additional reference for path.
331 + */
332 +struct file *vfs_open(struct path *path, int flags, const struct cred *cred)
333 +{
334 struct file *f;
335 + struct inode *inode = path->dentry->d_inode;
336
337 validate_creds(cred);
338
339 - /*
340 - * We must always pass in a valid mount pointer. Historically
341 - * callers got away with not passing it, but we must enforce this at
342 - * the earliest possible point now to avoid strange problems deep in the
343 - * filesystem stack.
344 - */
345 - if (!mnt) {
346 - printk(KERN_WARNING "%s called with NULL vfsmount\n", __func__);
347 - dump_stack();
348 - return ERR_PTR(-EINVAL);
349 - }
350 + if (inode->i_op->open)
351 + return inode->i_op->open(path->dentry, flags, cred);
352
353 - error = -ENFILE;
354 f = get_empty_filp();
355 - if (f == NULL) {
356 - dput(dentry);
357 - mntput(mnt);
358 - return ERR_PTR(error);
359 - }
360 + if (f == NULL)
361 + return ERR_PTR(-ENFILE);
362
363 f->f_flags = flags;
364 - return __dentry_open(dentry, mnt, f, NULL, cred);
365 + return __dentry_open(path, f, NULL, cred);
366 }
367 -EXPORT_SYMBOL(dentry_open);
368 +EXPORT_SYMBOL(vfs_open);
369
370 static void __put_unused_fd(struct files_struct *files, unsigned int fd)
371 {
372 --- /dev/null
373 +++ b/fs/overlayfs/Kconfig
374 @@ -0,0 +1,4 @@
375 +config OVERLAYFS_FS
376 + tristate "Overlay filesystem support"
377 + help
378 + Add support for overlay filesystem.
379 --- /dev/null
380 +++ b/fs/overlayfs/Makefile
381 @@ -0,0 +1,5 @@
382 +#
383 +# Makefile for the overlay filesystem.
384 +#
385 +
386 +obj-$(CONFIG_OVERLAYFS_FS) += overlayfs.o
387 --- /dev/null
388 +++ b/fs/overlayfs/overlayfs.c
389 @@ -0,0 +1,2358 @@
390 +#include <linux/fs.h>
391 +#include <linux/namei.h>
392 +#include <linux/sched.h>
393 +#include <linux/fs_struct.h>
394 +#include <linux/file.h>
395 +#include <linux/xattr.h>
396 +#include <linux/security.h>
397 +#include <linux/device_cgroup.h>
398 +#include <linux/mount.h>
399 +#include <linux/splice.h>
400 +#include <linux/slab.h>
401 +#include <linux/parser.h>
402 +#include <linux/module.h>
403 +#include <linux/uaccess.h>
404 +#include <linux/rbtree.h>
405 +
406 +MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
407 +MODULE_DESCRIPTION("Overlay filesystem");
408 +MODULE_LICENSE("GPL");
409 +
410 +#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
411 +
412 +struct ovl_fs {
413 + struct vfsmount *upper_mnt;
414 + struct vfsmount *lower_mnt;
415 +};
416 +
417 +struct ovl_entry {
418 + struct dentry *__upperdentry;
419 + struct dentry *lowerdentry;
420 + union {
421 + struct {
422 + u64 version;
423 + bool opaque;
424 + };
425 + struct rcu_head rcu;
426 + };
427 +};
428 +
429 +static const char *ovl_whiteout_xattr = "trusted.overlay.whiteout";
430 +static const char *ovl_opaque_xattr = "trusted.overlay.opaque";
431 +static const char *ovl_whiteout_symlink = "(overlay-whiteout)";
432 +
433 +enum ovl_path_type {
434 + OVL_PATH_UPPER,
435 + OVL_PATH_MERGE,
436 + OVL_PATH_LOWER,
437 +};
438 +
439 +static enum ovl_path_type ovl_path_type(struct dentry *dentry)
440 +{
441 + struct ovl_entry *oe = dentry->d_fsdata;
442 +
443 + if (oe->__upperdentry) {
444 + if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode))
445 + return OVL_PATH_MERGE;
446 + else
447 + return OVL_PATH_UPPER;
448 + } else {
449 + return OVL_PATH_LOWER;
450 + }
451 +}
452 +
453 +static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe)
454 +{
455 + struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry);
456 + smp_read_barrier_depends();
457 + return upperdentry;
458 +}
459 +
460 +static void ovl_path_upper(struct dentry *dentry, struct path *path)
461 +{
462 + struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
463 + struct ovl_entry *oe = dentry->d_fsdata;
464 +
465 + path->mnt = ofs->upper_mnt;
466 + path->dentry = ovl_upperdentry_dereference(oe);
467 +}
468 +
469 +static void ovl_path_lower(struct dentry *dentry, struct path *path)
470 +{
471 + struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
472 + struct ovl_entry *oe = dentry->d_fsdata;
473 +
474 + path->mnt = ofs->lower_mnt;
475 + path->dentry = oe->lowerdentry;
476 +}
477 +
478 +static enum ovl_path_type ovl_path_real(struct dentry *dentry,
479 + struct path *path)
480 +{
481 +
482 + enum ovl_path_type type = ovl_path_type(dentry);
483 +
484 + if (type == OVL_PATH_LOWER)
485 + ovl_path_lower(dentry, path);
486 + else
487 + ovl_path_upper(dentry, path);
488 +
489 + return type;
490 +}
491 +
492 +static struct dentry *ovl_dentry_upper(struct dentry *dentry)
493 +{
494 + struct ovl_entry *oe = dentry->d_fsdata;
495 +
496 + return ovl_upperdentry_dereference(oe);
497 +}
498 +
499 +static struct dentry *ovl_dentry_lower(struct dentry *dentry)
500 +{
501 + struct ovl_entry *oe = dentry->d_fsdata;
502 +
503 + return oe->lowerdentry;
504 +}
505 +
506 +static struct dentry *ovl_dentry_real(struct dentry *dentry)
507 +{
508 + struct ovl_entry *oe = dentry->d_fsdata;
509 + struct dentry *realdentry;
510 +
511 + realdentry = ovl_upperdentry_dereference(oe);
512 + if (!realdentry)
513 + realdentry = oe->lowerdentry;
514 +
515 + return realdentry;
516 +}
517 +
518 +static bool ovl_dentry_is_opaque(struct dentry *dentry)
519 +{
520 + struct ovl_entry *oe = dentry->d_fsdata;
521 + return oe->opaque;
522 +}
523 +
524 +static void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque)
525 +{
526 + struct ovl_entry *oe = dentry->d_fsdata;
527 + oe->opaque = opaque;
528 +}
529 +
530 +static void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry)
531 +{
532 + struct ovl_entry *oe = dentry->d_fsdata;
533 +
534 + WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex));
535 + WARN_ON(oe->__upperdentry);
536 + smp_wmb();
537 + oe->__upperdentry = upperdentry;
538 +}
539 +
540 +static void ovl_dentry_version_inc(struct dentry *dentry)
541 +{
542 + struct ovl_entry *oe = dentry->d_fsdata;
543 +
544 + WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
545 + oe->version++;
546 +}
547 +
548 +static u64 ovl_dentry_version_get(struct dentry *dentry)
549 +{
550 + struct ovl_entry *oe = dentry->d_fsdata;
551 +
552 + WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
553 + return oe->version;
554 +}
555 +
556 +static bool ovl_is_whiteout(struct dentry *dentry)
557 +{
558 + int res;
559 + char val;
560 +
561 + if (!dentry)
562 + return false;
563 + if (!dentry->d_inode)
564 + return false;
565 + if (!S_ISLNK(dentry->d_inode->i_mode))
566 + return false;
567 +
568 + res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1);
569 + if (res == 1 && val == 'y')
570 + return true;
571 +
572 + return false;
573 +}
574 +
575 +static bool ovl_is_opaquedir(struct dentry *dentry)
576 +{
577 + int res;
578 + char val;
579 +
580 + if (!S_ISDIR(dentry->d_inode->i_mode))
581 + return false;
582 +
583 + res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1);
584 + if (res == 1 && val == 'y')
585 + return true;
586 +
587 + return false;
588 +}
589 +
590 +struct ovl_cache_entry {
591 + const char *name;
592 + unsigned int len;
593 + unsigned int type;
594 + u64 ino;
595 + bool is_whiteout;
596 + struct list_head l_node;
597 + struct rb_node node;
598 +};
599 +
600 +struct ovl_readdir_data {
601 + struct rb_root *root;
602 + struct list_head *list;
603 + struct list_head *middle;
604 + struct dentry *dir;
605 + int count;
606 + int err;
607 +};
608 +
609 +struct ovl_dir_file {
610 + bool is_real;
611 + bool is_cached;
612 + struct list_head cursor;
613 + u64 cache_version;
614 + struct list_head cache;
615 + struct file *realfile;
616 +};
617 +
618 +static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n)
619 +{
620 + return container_of(n, struct ovl_cache_entry, node);
621 +}
622 +
623 +static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root,
624 + const char *name, int len)
625 +{
626 + struct rb_node *node = root->rb_node;
627 + int cmp;
628 +
629 + while (node) {
630 + struct ovl_cache_entry *p = ovl_cache_entry_from_node(node);
631 +
632 + cmp = strncmp(name, p->name, len);
633 + if (cmp > 0)
634 + node = p->node.rb_right;
635 + else if (cmp < 0 || len < p->len)
636 + node = p->node.rb_left;
637 + else
638 + return p;
639 + }
640 +
641 + return NULL;
642 +}
643 +
644 +static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len,
645 + u64 ino, unsigned int d_type,
646 + bool is_whiteout)
647 +{
648 + struct ovl_cache_entry *p;
649 +
650 + p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL);
651 + if (p) {
652 + char *name_copy = (char *) (p + 1);
653 + memcpy(name_copy, name, len);
654 + name_copy[len] = '\0';
655 + p->name = name_copy;
656 + p->len = len;
657 + p->type = d_type;
658 + p->ino = ino;
659 + p->is_whiteout = is_whiteout;
660 + }
661 +
662 + return p;
663 +}
664 +
665 +static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd,
666 + const char *name, int len, u64 ino,
667 + unsigned int d_type, bool is_whiteout)
668 +{
669 + struct rb_node **newp = &rdd->root->rb_node;
670 + struct rb_node *parent = NULL;
671 + struct ovl_cache_entry *p;
672 +
673 + while (*newp) {
674 + int cmp;
675 + struct ovl_cache_entry *tmp;
676 +
677 + parent = *newp;
678 + tmp = ovl_cache_entry_from_node(*newp);
679 + cmp = strncmp(name, tmp->name, len);
680 + if (cmp > 0)
681 + newp = &tmp->node.rb_right;
682 + else if (cmp < 0 || len < tmp->len)
683 + newp = &tmp->node.rb_left;
684 + else
685 + return 0;
686 + }
687 +
688 + p = ovl_cache_entry_new(name, len, ino, d_type, is_whiteout);
689 + if (p == NULL)
690 + return -ENOMEM;
691 +
692 + list_add_tail(&p->l_node, rdd->list);
693 + rb_link_node(&p->node, parent, newp);
694 + rb_insert_color(&p->node, rdd->root);
695 +
696 + return 0;
697 +}
698 +
699 +static int ovl_fill_lower(void *buf, const char *name, int namelen,
700 + loff_t offset, u64 ino, unsigned int d_type)
701 +{
702 + struct ovl_readdir_data *rdd = buf;
703 + struct ovl_cache_entry *p;
704 +
705 + rdd->count++;
706 + p = ovl_cache_entry_find(rdd->root, name, namelen);
707 + if (p) {
708 + list_move_tail(&p->l_node, rdd->middle);
709 + } else {
710 + p = ovl_cache_entry_new(name, namelen, ino, d_type, false);
711 + if (p == NULL)
712 + rdd->err = -ENOMEM;
713 + else
714 + list_add_tail(&p->l_node, rdd->middle);
715 + }
716 +
717 + return rdd->err;
718 +}
719 +
720 +static void ovl_cache_free(struct list_head *list)
721 +{
722 + struct ovl_cache_entry *p;
723 + struct ovl_cache_entry *n;
724 +
725 + list_for_each_entry_safe(p, n, list, l_node)
726 + kfree(p);
727 +
728 + INIT_LIST_HEAD(list);
729 +}
730 +
731 +static int ovl_fill_upper(void *buf, const char *name, int namelen,
732 + loff_t offset, u64 ino, unsigned int d_type)
733 +{
734 + struct ovl_readdir_data *rdd = buf;
735 + bool is_whiteout = false;
736 +
737 + rdd->count++;
738 + if (d_type == DT_LNK) {
739 + struct dentry *dentry;
740 +
741 + dentry = lookup_one_len(name, rdd->dir, namelen);
742 + if (IS_ERR(dentry)) {
743 + rdd->err = PTR_ERR(dentry);
744 + goto out;
745 + }
746 + is_whiteout = ovl_is_whiteout(dentry);
747 + dput(dentry);
748 + }
749 +
750 + rdd->err = ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type,
751 + is_whiteout);
752 +
753 +out:
754 + return rdd->err;
755 +}
756 +
757 +static int ovl_dir_read(struct path *realpath, struct ovl_readdir_data *rdd,
758 + filldir_t filler)
759 +{
760 + const struct cred *old_cred;
761 + struct cred *override_cred;
762 + struct file *realfile;
763 + int err;
764 +
765 + realfile = vfs_open(realpath, O_RDONLY | O_DIRECTORY, current_cred());
766 + if (IS_ERR(realfile))
767 + return PTR_ERR(realfile);
768 +
769 + err = -ENOMEM;
770 + override_cred = prepare_creds();
771 + if (override_cred) {
772 + /*
773 + * CAP_SYS_ADMIN for getxattr
774 + * CAP_DAC_OVERRIDE for lookup and unlink
775 + */
776 + cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
777 + cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
778 + old_cred = override_creds(override_cred);
779 +
780 + do {
781 + rdd->count = 0;
782 + rdd->err = 0;
783 + err = vfs_readdir(realfile, filler, rdd);
784 + if (err >= 0)
785 + err = rdd->err;
786 + } while (!err && rdd->count);
787 +
788 + revert_creds(old_cred);
789 + put_cred(override_cred);
790 + }
791 + fput(realfile);
792 +
793 + if (err) {
794 + if (rdd->list)
795 + ovl_cache_free(rdd->list);
796 + return err;
797 + }
798 +
799 + return 0;
800 +}
801 +
802 +static void ovl_dir_reset(struct file *file)
803 +{
804 + struct ovl_dir_file *od = file->private_data;
805 + enum ovl_path_type type = ovl_path_type(file->f_path.dentry);
806 +
807 + if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) {
808 + list_del_init(&od->cursor);
809 + ovl_cache_free(&od->cache);
810 + od->is_cached = false;
811 + }
812 + WARN_ON(!od->is_real && type != OVL_PATH_MERGE);
813 + if (od->is_real && type == OVL_PATH_MERGE) {
814 + fput(od->realfile);
815 + od->realfile = NULL;
816 + od->is_real = false;
817 + }
818 +}
819 +
820 +static int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath,
821 + struct ovl_readdir_data *rdd)
822 +{
823 + int err;
824 + struct rb_root root = RB_ROOT;
825 + struct list_head middle;
826 +
827 + rdd->root = &root;
828 + if (upperpath->dentry) {
829 + rdd->dir = upperpath->dentry;
830 + err = ovl_dir_read(upperpath, rdd, ovl_fill_upper);
831 + if (err)
832 + goto out;
833 + }
834 + /*
835 + * Insert lowerpath entries before upperpath ones, this allows
836 + * offsets to be reasonably constant
837 + */
838 + list_add(&middle, rdd->list);
839 + rdd->middle = &middle;
840 + err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower);
841 + list_del(&middle);
842 +out:
843 + rdd->root = NULL;
844 +
845 + return err;
846 +}
847 +
848 +static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
849 +{
850 + struct list_head *l;
851 + loff_t off;
852 +
853 + l = od->cache.next;
854 + for (off = 0; off < pos; off++) {
855 + if (l == &od->cache)
856 + break;
857 + l = l->next;
858 + }
859 + list_move_tail(&od->cursor, l);
860 +}
861 +
862 +static int ovl_readdir(struct file *file, void *buf, filldir_t filler)
863 +{
864 + struct ovl_dir_file *od = file->private_data;
865 + int res;
866 +
867 + if (!file->f_pos)
868 + ovl_dir_reset(file);
869 +
870 + if (od->is_real) {
871 + res = vfs_readdir(od->realfile, filler, buf);
872 + file->f_pos = od->realfile->f_pos;
873 +
874 + return res;
875 + }
876 +
877 + if (!od->is_cached) {
878 + struct path lowerpath;
879 + struct path upperpath;
880 + struct ovl_readdir_data rdd = { .list = &od->cache };
881 +
882 + ovl_path_lower(file->f_path.dentry, &lowerpath);
883 + ovl_path_upper(file->f_path.dentry, &upperpath);
884 +
885 + res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd);
886 + if (res)
887 + return res;
888 +
889 + od->cache_version = ovl_dentry_version_get(file->f_path.dentry);
890 + od->is_cached = true;
891 +
892 + ovl_seek_cursor(od, file->f_pos);
893 + }
894 +
895 + while (od->cursor.next != &od->cache) {
896 + int over;
897 + loff_t off;
898 + struct ovl_cache_entry *p;
899 +
900 + p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node);
901 + off = file->f_pos;
902 + file->f_pos++;
903 + list_move(&od->cursor, &p->l_node);
904 +
905 + if (p->is_whiteout)
906 + continue;
907 +
908 + over = filler(buf, p->name, p->len, off, p->ino, p->type);
909 + if (over)
910 + break;
911 + }
912 +
913 + return 0;
914 +}
915 +
916 +static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin)
917 +{
918 + loff_t res;
919 + struct ovl_dir_file *od = file->private_data;
920 +
921 + mutex_lock(&file->f_dentry->d_inode->i_mutex);
922 + if (!file->f_pos)
923 + ovl_dir_reset(file);
924 +
925 + if (od->is_real) {
926 + res = vfs_llseek(od->realfile, offset, origin);
927 + file->f_pos = od->realfile->f_pos;
928 + } else {
929 + res = -EINVAL;
930 +
931 + switch (origin) {
932 + case SEEK_CUR:
933 + offset += file->f_pos;
934 + break;
935 + case SEEK_SET:
936 + break;
937 + default:
938 + goto out_unlock;
939 + }
940 + if (offset < 0)
941 + goto out_unlock;
942 +
943 + if (offset != file->f_pos) {
944 + file->f_pos = offset;
945 + if (od->is_cached)
946 + ovl_seek_cursor(od, offset);
947 + }
948 + res = offset;
949 + }
950 +out_unlock:
951 + mutex_unlock(&file->f_dentry->d_inode->i_mutex);
952 +
953 + return res;
954 +}
955 +
956 +static int ovl_dir_fsync(struct file *file, int datasync)
957 +{
958 + struct ovl_dir_file *od = file->private_data;
959 +
960 + /* May need to reopen directory if it got copied up */
961 + if (!od->realfile) {
962 + struct path upperpath;
963 +
964 + ovl_path_upper(file->f_path.dentry, &upperpath);
965 + od->realfile = vfs_open(&upperpath, O_RDONLY, current_cred());
966 + if (IS_ERR(od->realfile))
967 + return PTR_ERR(od->realfile);
968 + }
969 +
970 + return vfs_fsync(od->realfile, datasync);
971 +}
972 +
973 +static int ovl_dir_release(struct inode *inode, struct file *file)
974 +{
975 + struct ovl_dir_file *od = file->private_data;
976 +
977 + list_del(&od->cursor);
978 + ovl_cache_free(&od->cache);
979 + if (od->realfile)
980 + fput(od->realfile);
981 + kfree(od);
982 +
983 + return 0;
984 +}
985 +
986 +static int ovl_dir_open(struct inode *inode, struct file *file)
987 +{
988 + struct path realpath;
989 + struct file *realfile;
990 + struct ovl_dir_file *od;
991 + enum ovl_path_type type;
992 +
993 + od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL);
994 + if (!od)
995 + return -ENOMEM;
996 +
997 + type = ovl_path_real(file->f_path.dentry, &realpath);
998 + realfile = vfs_open(&realpath, file->f_flags, current_cred());
999 + if (IS_ERR(realfile)) {
1000 + kfree(od);
1001 + return PTR_ERR(realfile);
1002 + }
1003 + INIT_LIST_HEAD(&od->cache);
1004 + INIT_LIST_HEAD(&od->cursor);
1005 + od->is_cached = false;
1006 + od->realfile = realfile;
1007 + od->is_real = (type != OVL_PATH_MERGE);
1008 + file->private_data = od;
1009 +
1010 + return 0;
1011 +}
1012 +
1013 +static const struct file_operations ovl_dir_operations = {
1014 + .read = generic_read_dir,
1015 + .open = ovl_dir_open,
1016 + .readdir = ovl_readdir,
1017 + .llseek = ovl_dir_llseek,
1018 + .fsync = ovl_dir_fsync,
1019 + .release = ovl_dir_release,
1020 +};
1021 +
1022 +static const struct inode_operations ovl_dir_inode_operations;
1023 +
1024 +static void ovl_entry_free(struct rcu_head *head)
1025 +{
1026 + struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu);
1027 + kfree(oe);
1028 +}
1029 +
1030 +static void ovl_dentry_release(struct dentry *dentry)
1031 +{
1032 + struct ovl_entry *oe = dentry->d_fsdata;
1033 +
1034 + if (oe) {
1035 + dput(oe->__upperdentry);
1036 + dput(oe->lowerdentry);
1037 + call_rcu(&oe->rcu, ovl_entry_free);
1038 + }
1039 +}
1040 +
1041 +static const struct dentry_operations ovl_dentry_operations = {
1042 + .d_release = ovl_dentry_release,
1043 +};
1044 +
1045 +static struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name)
1046 +{
1047 + struct dentry *dentry;
1048 +
1049 + mutex_lock(&dir->d_inode->i_mutex);
1050 + dentry = lookup_one_len(name->name, dir, name->len);
1051 + mutex_unlock(&dir->d_inode->i_mutex);
1052 +
1053 + if (IS_ERR(dentry)) {
1054 + if (PTR_ERR(dentry) == -ENOENT)
1055 + dentry = NULL;
1056 + } else if (!dentry->d_inode) {
1057 + dput(dentry);
1058 + dentry = NULL;
1059 + }
1060 + return dentry;
1061 +}
1062 +
1063 +static struct ovl_entry *ovl_alloc_entry(void)
1064 +{
1065 + return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL);
1066 +}
1067 +
1068 +static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode,
1069 + struct ovl_entry *oe);
1070 +
1071 +static struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
1072 + struct nameidata *nd)
1073 +{
1074 + struct ovl_entry *oe;
1075 + struct dentry *upperdir;
1076 + struct dentry *lowerdir;
1077 + struct dentry *upperdentry = NULL;
1078 + struct dentry *lowerdentry = NULL;
1079 + struct inode *inode = NULL;
1080 + int err;
1081 +
1082 + err = -ENOMEM;
1083 + oe = ovl_alloc_entry();
1084 + if (!oe)
1085 + goto out;
1086 +
1087 + upperdir = ovl_dentry_upper(dentry->d_parent);
1088 + lowerdir = ovl_dentry_lower(dentry->d_parent);
1089 +
1090 + if (upperdir) {
1091 + upperdentry = ovl_lookup_real(upperdir, &dentry->d_name);
1092 + err = PTR_ERR(upperdentry);
1093 + if (IS_ERR(upperdentry))
1094 + goto out_put_dir;
1095 +
1096 + if (lowerdir && upperdentry &&
1097 + (S_ISLNK(upperdentry->d_inode->i_mode) ||
1098 + S_ISDIR(upperdentry->d_inode->i_mode))) {
1099 + const struct cred *old_cred;
1100 + struct cred *override_cred;
1101 +
1102 + err = -ENOMEM;
1103 + override_cred = prepare_creds();
1104 + if (!override_cred)
1105 + goto out_dput_upper;
1106 +
1107 + /* CAP_SYS_ADMIN needed for getxattr */
1108 + cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
1109 + old_cred = override_creds(override_cred);
1110 +
1111 + if (ovl_is_opaquedir(upperdentry)) {
1112 + oe->opaque = true;
1113 + } else if (ovl_is_whiteout(upperdentry)) {
1114 + dput(upperdentry);
1115 + upperdentry = NULL;
1116 + oe->opaque = true;
1117 + }
1118 + revert_creds(old_cred);
1119 + put_cred(override_cred);
1120 + }
1121 + }
1122 + if (lowerdir && !oe->opaque) {
1123 + lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name);
1124 + err = PTR_ERR(lowerdentry);
1125 + if (IS_ERR(lowerdentry))
1126 + goto out_dput_upper;
1127 + }
1128 +
1129 + if (lowerdentry && upperdentry &&
1130 + (!S_ISDIR(upperdentry->d_inode->i_mode) ||
1131 + !S_ISDIR(lowerdentry->d_inode->i_mode))) {
1132 + dput(lowerdentry);
1133 + lowerdentry = NULL;
1134 + oe->opaque = true;
1135 + }
1136 +
1137 + if (lowerdentry || upperdentry) {
1138 + struct dentry *realdentry;
1139 +
1140 + realdentry = upperdentry ? upperdentry : lowerdentry;
1141 + err = -ENOMEM;
1142 + inode = ovl_new_inode(dir->i_sb, realdentry->d_inode->i_mode, oe);
1143 + if (!inode)
1144 + goto out_dput;
1145 + }
1146 +
1147 + if (upperdentry)
1148 + oe->__upperdentry = upperdentry;
1149 +
1150 + if (lowerdentry)
1151 + oe->lowerdentry = lowerdentry;
1152 +
1153 + dentry->d_fsdata = oe;
1154 + dentry->d_op = &ovl_dentry_operations;
1155 + d_add(dentry, inode);
1156 +
1157 + return NULL;
1158 +
1159 +out_dput:
1160 + dput(lowerdentry);
1161 +out_dput_upper:
1162 + dput(upperdentry);
1163 +out_put_dir:
1164 + kfree(oe);
1165 +out:
1166 + return ERR_PTR(err);
1167 +}
1168 +
1169 +static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new)
1170 +{
1171 + ssize_t list_size, size;
1172 + char *buf, *name, *value;
1173 + int error;
1174 +
1175 + if (!old->d_inode->i_op->getxattr ||
1176 + !new->d_inode->i_op->getxattr)
1177 + return 0;
1178 +
1179 + list_size = vfs_listxattr(old, NULL, 0);
1180 + if (list_size <= 0) {
1181 + if (list_size == -EOPNOTSUPP)
1182 + return 0;
1183 + return list_size;
1184 + }
1185 +
1186 + buf = kzalloc(list_size, GFP_KERNEL);
1187 + if (!buf)
1188 + return -ENOMEM;
1189 +
1190 + error = -ENOMEM;
1191 + value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL);
1192 + if (!value)
1193 + goto out;
1194 +
1195 + list_size = vfs_listxattr(old, buf, list_size);
1196 + if (list_size <= 0) {
1197 + error = list_size;
1198 + goto out_free_value;
1199 + }
1200 +
1201 + for (name = buf; name < (buf + list_size); name += strlen(name) + 1) {
1202 + size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX);
1203 + if (size <= 0) {
1204 + error = size;
1205 + goto out_free_value;
1206 + }
1207 + error = vfs_setxattr(new, name, value, size, 0);
1208 + if (error)
1209 + goto out_free_value;
1210 + }
1211 +
1212 +out_free_value:
1213 + kfree(value);
1214 +out:
1215 + kfree(buf);
1216 + return error;
1217 +}
1218 +
1219 +static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
1220 +{
1221 + struct file *old_file;
1222 + struct file *new_file;
1223 + int error = 0;
1224 +
1225 + if (len == 0)
1226 + return 0;
1227 +
1228 + old_file = vfs_open(old, O_RDONLY, current_cred());
1229 + if (IS_ERR(old_file))
1230 + return PTR_ERR(old_file);
1231 +
1232 + new_file = vfs_open(new, O_WRONLY, current_cred());
1233 + if (IS_ERR(new_file)) {
1234 + error = PTR_ERR(new_file);
1235 + goto out_fput;
1236 + }
1237 +
1238 + /* FIXME: copy up sparse files efficiently */
1239 + while (len) {
1240 + loff_t offset = new_file->f_pos;
1241 + size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
1242 + long bytes;
1243 +
1244 + if (len < this_len)
1245 + this_len = len;
1246 +
1247 + if (signal_pending_state(TASK_KILLABLE, current))
1248 + return -EINTR;
1249 +
1250 + bytes = do_splice_direct(old_file, &offset, new_file, this_len,
1251 + SPLICE_F_MOVE);
1252 + if (bytes <= 0) {
1253 + error = bytes;
1254 + break;
1255 + }
1256 +
1257 + len -= bytes;
1258 + }
1259 +
1260 + fput(new_file);
1261 +out_fput:
1262 + fput(old_file);
1263 + return error;
1264 +}
1265 +
1266 +static struct dentry *ovl_lookup_create(struct dentry *upperdir,
1267 + struct dentry *template)
1268 +{
1269 + int err;
1270 + struct dentry *newdentry;
1271 + struct qstr *name = &template->d_name;
1272 +
1273 + newdentry = lookup_one_len(name->name, upperdir, name->len);
1274 + if (IS_ERR(newdentry))
1275 + return newdentry;
1276 +
1277 + if (newdentry->d_inode) {
1278 + const struct cred *old_cred;
1279 + struct cred *override_cred;
1280 +
1281 + /* No need to check whiteout if lower parent is non-existent */
1282 + err = -EEXIST;
1283 + if (!ovl_dentry_lower(template->d_parent))
1284 + goto out_dput;
1285 +
1286 + if (!S_ISLNK(newdentry->d_inode->i_mode))
1287 + goto out_dput;
1288 +
1289 + err = -ENOMEM;
1290 + override_cred = prepare_creds();
1291 + if (!override_cred)
1292 + goto out_dput;
1293 +
1294 + /*
1295 + * CAP_SYS_ADMIN for getxattr
1296 + * CAP_FOWNER for unlink in sticky directory
1297 + */
1298 + cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
1299 + cap_raise(override_cred->cap_effective, CAP_FOWNER);
1300 + old_cred = override_creds(override_cred);
1301 +
1302 + err = -EEXIST;
1303 + if (ovl_is_whiteout(newdentry))
1304 + err = vfs_unlink(upperdir->d_inode, newdentry);
1305 +
1306 + revert_creds(old_cred);
1307 + put_cred(override_cred);
1308 + if (err)
1309 + goto out_dput;
1310 +
1311 + dput(newdentry);
1312 + newdentry = lookup_one_len(name->name, upperdir, name->len);
1313 + if (IS_ERR(newdentry))
1314 + return newdentry;
1315 +
1316 + /*
1317 + * Whiteout just been successfully removed, parent
1318 + * i_mutex is still held, there's no way the lookup
1319 + * could return positive.
1320 + */
1321 + WARN_ON(newdentry->d_inode);
1322 + }
1323 +
1324 + return newdentry;
1325 +
1326 +out_dput:
1327 + dput(newdentry);
1328 + return ERR_PTR(err);
1329 +}
1330 +
1331 +static struct dentry *ovl_upper_create(struct dentry *upperdir,
1332 + struct dentry *dentry,
1333 + struct kstat *stat, const char *link)
1334 +{
1335 + int err;
1336 + struct dentry *newdentry;
1337 + struct inode *dir = upperdir->d_inode;
1338 +
1339 + newdentry = ovl_lookup_create(upperdir, dentry);
1340 + if (IS_ERR(newdentry))
1341 + goto out;
1342 +
1343 + switch (stat->mode & S_IFMT) {
1344 + case S_IFREG:
1345 + err = vfs_create(dir, newdentry, stat->mode, NULL);
1346 + break;
1347 +
1348 + case S_IFDIR:
1349 + err = vfs_mkdir(dir, newdentry, stat->mode);
1350 + break;
1351 +
1352 + case S_IFCHR:
1353 + case S_IFBLK:
1354 + case S_IFIFO:
1355 + case S_IFSOCK:
1356 + err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev);
1357 + break;
1358 +
1359 + case S_IFLNK:
1360 + err = vfs_symlink(dir, newdentry, link);
1361 + break;
1362 +
1363 + default:
1364 + err = -EPERM;
1365 + }
1366 + if (err) {
1367 + dput(newdentry);
1368 + newdentry = ERR_PTR(err);
1369 + }
1370 +
1371 +out:
1372 + return newdentry;
1373 +
1374 +}
1375 +
1376 +static char *ovl_read_symlink(struct dentry *realdentry)
1377 +{
1378 + int res;
1379 + char *buf;
1380 + struct inode *inode = realdentry->d_inode;
1381 + mm_segment_t old_fs;
1382 +
1383 + res = -EINVAL;
1384 + if (!inode->i_op->readlink)
1385 + goto err;
1386 +
1387 + res = -ENOMEM;
1388 + buf = (char *) __get_free_page(GFP_KERNEL);
1389 + if (!buf)
1390 + goto err;
1391 +
1392 + old_fs = get_fs();
1393 + set_fs(get_ds());
1394 + /* The cast to a user pointer is valid due to the set_fs() */
1395 + res = inode->i_op->readlink(realdentry,
1396 + (char __user *)buf, PAGE_SIZE - 1);
1397 + set_fs(old_fs);
1398 + if (res < 0) {
1399 + free_page((unsigned long) buf);
1400 + goto err;
1401 + }
1402 + buf[res] = '\0';
1403 +
1404 + return buf;
1405 +
1406 +err:
1407 + return ERR_PTR(res);
1408 +}
1409 +
1410 +static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
1411 +{
1412 + struct iattr attr = {
1413 + .ia_valid = ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
1414 + .ia_atime = stat->atime,
1415 + .ia_mtime = stat->mtime,
1416 + };
1417 +
1418 + return notify_change(upperdentry, &attr);
1419 +}
1420 +
1421 +static int ovl_set_mode(struct dentry *upperdentry, umode_t mode)
1422 +{
1423 + struct iattr attr = {
1424 + .ia_valid = ATTR_MODE,
1425 + .ia_mode = mode,
1426 + };
1427 +
1428 + return notify_change(upperdentry, &attr);
1429 +}
1430 +
1431 +static int ovl_set_opaque(struct dentry *upperdentry)
1432 +{
1433 + int err;
1434 + const struct cred *old_cred;
1435 + struct cred *override_cred;
1436 +
1437 + override_cred = prepare_creds();
1438 + if (!override_cred)
1439 + return -ENOMEM;
1440 +
1441 + /* CAP_SYS_ADMIN for setxattr of "trusted" namespace */
1442 + cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
1443 + old_cred = override_creds(override_cred);
1444 + err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0);
1445 + revert_creds(old_cred);
1446 + put_cred(override_cred);
1447 +
1448 + return err;
1449 +}
1450 +
1451 +static int ovl_remove_opaque(struct dentry *upperdentry)
1452 +{
1453 + int err;
1454 + const struct cred *old_cred;
1455 + struct cred *override_cred;
1456 +
1457 + override_cred = prepare_creds();
1458 + if (!override_cred)
1459 + return -ENOMEM;
1460 +
1461 + /* CAP_SYS_ADMIN for removexattr of "trusted" namespace */
1462 + cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
1463 + old_cred = override_creds(override_cred);
1464 + err = vfs_removexattr(upperdentry, ovl_opaque_xattr);
1465 + revert_creds(old_cred);
1466 + put_cred(override_cred);
1467 +
1468 + return err;
1469 +}
1470 +
1471 +static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry,
1472 + struct path *lowerpath, struct kstat *stat,
1473 + const char *link)
1474 +{
1475 + int err;
1476 + struct path newpath;
1477 + umode_t mode = stat->mode;
1478 + struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
1479 +
1480 + /* Can't properly set mode on creation because of the umask */
1481 + stat->mode &= S_IFMT;
1482 +
1483 + newpath.mnt = ofs->upper_mnt;
1484 + newpath.dentry = ovl_upper_create(upperdir, dentry, stat, link);
1485 + if (IS_ERR(newpath.dentry)) {
1486 + err = PTR_ERR(newpath.dentry);
1487 +
1488 + /* Already copied up? */
1489 + if (err == -EEXIST && ovl_path_type(dentry) != OVL_PATH_LOWER)
1490 + return 0;
1491 +
1492 + return err;
1493 + }
1494 +
1495 + /* FIXME: recovery from failure to copy up */
1496 +
1497 + if (S_ISREG(stat->mode)) {
1498 + err = ovl_copy_up_data(lowerpath, &newpath, stat->size);
1499 + if (err)
1500 + return err;
1501 + }
1502 +
1503 + err = ovl_copy_up_xattr(lowerpath->dentry, newpath.dentry);
1504 + if (err)
1505 + return err;
1506 +
1507 + mutex_lock(&newpath.dentry->d_inode->i_mutex);
1508 + if (!S_ISLNK(stat->mode))
1509 + err = ovl_set_mode(newpath.dentry, mode);
1510 + if (!err)
1511 + err = ovl_set_timestamps(newpath.dentry, stat);
1512 + mutex_unlock(&newpath.dentry->d_inode->i_mutex);
1513 + if (err)
1514 + return err;
1515 +
1516 + ovl_dentry_update(dentry, newpath.dentry);
1517 +
1518 + /*
1519 + * Easiest way to get rid of the lower dentry reference is to
1520 + * drop this dentry. This is neither needed nor possible for
1521 + * directories.
1522 + */
1523 + if (!S_ISDIR(stat->mode))
1524 + d_drop(dentry);
1525 +
1526 + return 0;
1527 +}
1528 +
1529 +static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
1530 + struct path *lowerpath, struct kstat *stat)
1531 +{
1532 + int err;
1533 + struct kstat pstat;
1534 + struct path parentpath;
1535 + struct dentry *upperdir;
1536 + const struct cred *old_cred;
1537 + struct cred *override_cred;
1538 + char *link = NULL;
1539 +
1540 + ovl_path_upper(parent, &parentpath);
1541 + upperdir = parentpath.dentry;
1542 +
1543 + err = vfs_getattr(parentpath.mnt, parentpath.dentry, &pstat);
1544 + if (err)
1545 + return err;
1546 +
1547 + if (S_ISLNK(stat->mode)) {
1548 + link = ovl_read_symlink(lowerpath->dentry);
1549 + if (IS_ERR(link))
1550 + return PTR_ERR(link);
1551 + }
1552 +
1553 + err = -ENOMEM;
1554 + override_cred = prepare_creds();
1555 + if (!override_cred)
1556 + goto out_free_link;
1557 +
1558 + override_cred->fsuid = stat->uid;
1559 + override_cred->fsgid = stat->gid;
1560 + /*
1561 + * CAP_SYS_ADMIN for copying up extended attributes
1562 + * CAP_DAC_OVERRIDE for create
1563 + * CAP_FOWNER for chmod, timestamp update
1564 + * CAP_FSETID for chmod
1565 + * CAP_MKNOD for mknod
1566 + */
1567 + cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
1568 + cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
1569 + cap_raise(override_cred->cap_effective, CAP_FOWNER);
1570 + cap_raise(override_cred->cap_effective, CAP_FSETID);
1571 + cap_raise(override_cred->cap_effective, CAP_MKNOD);
1572 + old_cred = override_creds(override_cred);
1573 +
1574 + mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
1575 + /*
1576 + * Using upper filesystem locking to protect against copy up
1577 + * racing with rename (rename means the copy up was already
1578 + * successful).
1579 + */
1580 + if (dentry->d_parent != parent) {
1581 + WARN_ON((ovl_path_type(dentry) == OVL_PATH_LOWER));
1582 + err = 0;
1583 + } else {
1584 + err = ovl_copy_up_locked(upperdir, dentry, lowerpath,
1585 + stat, link);
1586 + if (!err) {
1587 + /* Restore timestamps on parent (best effort) */
1588 + ovl_set_timestamps(upperdir, &pstat);
1589 + }
1590 + }
1591 +
1592 + mutex_unlock(&upperdir->d_inode->i_mutex);
1593 +
1594 + revert_creds(old_cred);
1595 + put_cred(override_cred);
1596 +
1597 +out_free_link:
1598 + if (link)
1599 + free_page((unsigned long) link);
1600 +
1601 + return err;
1602 +}
1603 +
1604 +static int ovl_copy_up(struct dentry *dentry)
1605 +{
1606 + int err;
1607 +
1608 + err = 0;
1609 + while (!err) {
1610 + struct dentry *next;
1611 + struct dentry *parent;
1612 + struct path lowerpath;
1613 + struct kstat stat;
1614 + enum ovl_path_type type = ovl_path_type(dentry);
1615 +
1616 + if (type != OVL_PATH_LOWER)
1617 + break;
1618 +
1619 + next = dget(dentry);
1620 + /* find the topmost dentry not yet copied up */
1621 + for (;;) {
1622 + parent = dget_parent(next);
1623 +
1624 + type = ovl_path_type(parent);
1625 + if (type != OVL_PATH_LOWER)
1626 + break;
1627 +
1628 + dput(next);
1629 + next = parent;
1630 + }
1631 +
1632 + ovl_path_lower(next, &lowerpath);
1633 + err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat);
1634 + if (!err)
1635 + err = ovl_copy_up_one(parent, next, &lowerpath, &stat);
1636 +
1637 + dput(parent);
1638 + dput(next);
1639 + }
1640 +
1641 + return err;
1642 +}
1643 +
1644 +/* Optimize by not copying up the file first and truncating later */
1645 +static int ovl_copy_up_truncate(struct dentry *dentry, loff_t size)
1646 +{
1647 + int err;
1648 + struct kstat stat;
1649 + struct path lowerpath;
1650 + struct dentry *parent = dget_parent(dentry);
1651 +
1652 + err = ovl_copy_up(parent);
1653 + if (err)
1654 + goto out_dput_parent;
1655 +
1656 + ovl_path_lower(dentry, &lowerpath);
1657 + err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat);
1658 + if (err)
1659 + goto out_dput_parent;
1660 +
1661 + if (size < stat.size)
1662 + stat.size = size;
1663 +
1664 + err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat);
1665 +
1666 +out_dput_parent:
1667 + dput(parent);
1668 + return err;
1669 +}
1670 +
1671 +static int ovl_setattr(struct dentry *dentry, struct iattr *attr)
1672 +{
1673 + struct dentry *upperdentry;
1674 + int err;
1675 +
1676 + if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry))
1677 + err = ovl_copy_up_truncate(dentry, attr->ia_size);
1678 + else
1679 + err = ovl_copy_up(dentry);
1680 + if (err)
1681 + return err;
1682 +
1683 + upperdentry = ovl_dentry_upper(dentry);
1684 +
1685 + if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1686 + attr->ia_valid &= ~ATTR_MODE;
1687 +
1688 + mutex_lock(&upperdentry->d_inode->i_mutex);
1689 + err = notify_change(upperdentry, attr);
1690 + mutex_unlock(&upperdentry->d_inode->i_mutex);
1691 +
1692 + return err;
1693 +}
1694 +
1695 +static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry,
1696 + struct kstat *stat)
1697 +{
1698 + struct path realpath;
1699 +
1700 + ovl_path_real(dentry, &realpath);
1701 + return vfs_getattr(realpath.mnt, realpath.dentry, stat);
1702 +}
1703 +
1704 +static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry,
1705 + struct kstat *stat)
1706 +{
1707 + int err;
1708 + enum ovl_path_type type;
1709 + struct path realpath;
1710 +
1711 + type = ovl_path_real(dentry, &realpath);
1712 + err = vfs_getattr(realpath.mnt, realpath.dentry, stat);
1713 + if (err)
1714 + return err;
1715 +
1716 + stat->dev = dentry->d_sb->s_dev;
1717 + stat->ino = dentry->d_inode->i_ino;
1718 +
1719 + /*
1720 + * It's probably not worth it to count subdirs to get the
1721 + * correct link count. nlink=1 seems to pacify 'find' and
1722 + * other utilities.
1723 + */
1724 + if (type == OVL_PATH_MERGE)
1725 + stat->nlink = 1;
1726 +
1727 + return 0;
1728 +}
1729 +
1730 +static int ovl_permission(struct inode *inode, int mask, unsigned int flags)
1731 +{
1732 + struct ovl_entry *oe;
1733 + struct dentry *alias = NULL;
1734 + struct inode *realinode;
1735 + struct dentry *realdentry;
1736 + bool is_upper;
1737 + int err;
1738 +
1739 + if (S_ISDIR(inode->i_mode)) {
1740 + oe = inode->i_private;
1741 + } else if (flags & IPERM_FLAG_RCU) {
1742 + return -ECHILD;
1743 + } else {
1744 + /*
1745 + * For non-directories find an alias and get the info
1746 + * from there.
1747 + */
1748 + spin_lock(&inode->i_lock);
1749 + if (WARN_ON(list_empty(&inode->i_dentry))) {
1750 + spin_unlock(&inode->i_lock);
1751 + return -ENOENT;
1752 + }
1753 + alias = list_entry(inode->i_dentry.next, struct dentry, d_alias);
1754 + dget(alias);
1755 + spin_unlock(&inode->i_lock);
1756 + oe = alias->d_fsdata;
1757 + }
1758 +
1759 + realdentry = ovl_upperdentry_dereference(oe);
1760 + is_upper = true;
1761 + if (!realdentry) {
1762 + realdentry = oe->lowerdentry;
1763 + is_upper = false;
1764 + }
1765 +
1766 + /* Careful in RCU walk mode */
1767 + realinode = ACCESS_ONCE(realdentry->d_inode);
1768 + if (!realinode) {
1769 + WARN_ON(!(flags & IPERM_FLAG_RCU));
1770 + return -ENOENT;
1771 + }
1772 +
1773 + if (mask & MAY_WRITE) {
1774 + umode_t mode = realinode->i_mode;
1775 +
1776 + /*
1777 + * Writes will always be redirected to upper layer, so
1778 + * ignore lower layer being read-only.
1779 + */
1780 + err = -EROFS;
1781 + if (is_upper && IS_RDONLY(realinode) &&
1782 + (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
1783 + goto out_dput;
1784 +
1785 + /*
1786 + * Nobody gets write access to an immutable file.
1787 + */
1788 + err = -EACCES;
1789 + if (IS_IMMUTABLE(realinode))
1790 + goto out_dput;
1791 + }
1792 +
1793 + if (realinode->i_op->permission)
1794 + err = realinode->i_op->permission(realinode, mask, flags);
1795 + else
1796 + err = generic_permission(realinode, mask, flags,
1797 + realinode->i_op->check_acl);
1798 +out_dput:
1799 + dput(alias);
1800 + return err;
1801 +}
1802 +
1803 +static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
1804 + const char *link)
1805 +{
1806 + int err;
1807 + struct dentry *newdentry;
1808 + struct dentry *upperdir;
1809 + struct inode *inode;
1810 + struct kstat stat = {
1811 + .mode = mode,
1812 + .rdev = rdev,
1813 + };
1814 +
1815 + err = -ENOMEM;
1816 + inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata);
1817 + if (!inode)
1818 + goto out;
1819 +
1820 + err = ovl_copy_up(dentry->d_parent);
1821 + if (err)
1822 + goto out_iput;
1823 +
1824 + upperdir = ovl_dentry_upper(dentry->d_parent);
1825 + mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
1826 +
1827 + newdentry = ovl_upper_create(upperdir, dentry, &stat, link);
1828 + err = PTR_ERR(newdentry);
1829 + if (IS_ERR(newdentry))
1830 + goto out_unlock;
1831 +
1832 + ovl_dentry_version_inc(dentry->d_parent);
1833 + if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) {
1834 + err = ovl_set_opaque(newdentry);
1835 + if (err)
1836 + goto out_dput;
1837 + }
1838 + ovl_dentry_update(dentry, newdentry);
1839 + d_instantiate(dentry, inode);
1840 + inode = NULL;
1841 + newdentry = NULL;
1842 + err = 0;
1843 +
1844 +out_dput:
1845 + dput(newdentry);
1846 +out_unlock:
1847 + mutex_unlock(&upperdir->d_inode->i_mutex);
1848 +out_iput:
1849 + iput(inode);
1850 +out:
1851 + return err;
1852 +}
1853 +
1854 +static int ovl_create(struct inode *dir, struct dentry *dentry, int mode,
1855 + struct nameidata *nd)
1856 +{
1857 + return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
1858 +}
1859 +
1860 +static int ovl_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1861 +{
1862 + return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
1863 +}
1864 +
1865 +static int ovl_mknod(struct inode *dir, struct dentry *dentry, int mode,
1866 + dev_t rdev)
1867 +{
1868 + return ovl_create_object(dentry, mode, rdev, NULL);
1869 +}
1870 +
1871 +static int ovl_symlink(struct inode *dir, struct dentry *dentry,
1872 + const char *link)
1873 +{
1874 + return ovl_create_object(dentry, S_IFLNK, 0, link);
1875 +}
1876 +
1877 +struct ovl_link_data {
1878 + struct dentry *realdentry;
1879 + void *cookie;
1880 +};
1881 +
1882 +static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd)
1883 +{
1884 + void *ret;
1885 + struct dentry *realdentry;
1886 + struct inode *realinode;
1887 +
1888 + realdentry = ovl_dentry_real(dentry);
1889 + realinode = realdentry->d_inode;
1890 +
1891 + if (WARN_ON(!realinode->i_op->follow_link))
1892 + return ERR_PTR(-EPERM);
1893 +
1894 + ret = realinode->i_op->follow_link(realdentry, nd);
1895 + if (IS_ERR(ret))
1896 + return ret;
1897 +
1898 + if (realinode->i_op->put_link) {
1899 + struct ovl_link_data *data;
1900 +
1901 + data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL);
1902 + if (!data) {
1903 + realinode->i_op->put_link(realdentry, nd, ret);
1904 + return ERR_PTR(-ENOMEM);
1905 + }
1906 + data->realdentry = realdentry;
1907 + data->cookie = ret;
1908 +
1909 + return data;
1910 + } else {
1911 + return NULL;
1912 + }
1913 +}
1914 +
1915 +static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1916 +{
1917 + struct inode *realinode;
1918 + struct ovl_link_data *data = c;
1919 +
1920 + if (!data)
1921 + return;
1922 +
1923 + realinode = data->realdentry->d_inode;
1924 + realinode->i_op->put_link(data->realdentry, nd, data->cookie);
1925 + kfree(data);
1926 +}
1927 +
1928 +static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
1929 +{
1930 + struct path realpath;
1931 + struct inode *realinode;
1932 +
1933 + ovl_path_real(dentry, &realpath);
1934 + realinode = realpath.dentry->d_inode;
1935 +
1936 + if (!realinode->i_op->readlink)
1937 + return -EINVAL;
1938 +
1939 + touch_atime(realpath.mnt, realpath.dentry);
1940 +
1941 + return realinode->i_op->readlink(realpath.dentry, buf, bufsiz);
1942 +}
1943 +
1944 +static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry)
1945 +{
1946 + int err;
1947 + struct dentry *newdentry;
1948 + const struct cred *old_cred;
1949 + struct cred *override_cred;
1950 +
1951 + /* FIXME: recheck lower dentry to see if whiteout is really needed */
1952 +
1953 + err = -ENOMEM;
1954 + override_cred = prepare_creds();
1955 + if (!override_cred)
1956 + goto out;
1957 +
1958 + /*
1959 + * CAP_SYS_ADMIN for setxattr
1960 + * CAP_DAC_OVERRIDE for symlink creation
1961 + */
1962 + cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
1963 + cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
1964 + override_cred->fsuid = 0;
1965 + override_cred->fsgid = 0;
1966 + old_cred = override_creds(override_cred);
1967 +
1968 + newdentry = lookup_one_len(dentry->d_name.name, upperdir,
1969 + dentry->d_name.len);
1970 + err = PTR_ERR(newdentry);
1971 + if (IS_ERR(newdentry))
1972 + goto out_put_cred;
1973 +
1974 + /* Just been removed within the same locked region */
1975 + WARN_ON(newdentry->d_inode);
1976 +
1977 + err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink);
1978 + if (err)
1979 + goto out_dput;
1980 +
1981 + ovl_dentry_version_inc(dentry->d_parent);
1982 +
1983 + err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0);
1984 +
1985 +out_dput:
1986 + dput(newdentry);
1987 +out_put_cred:
1988 + revert_creds(old_cred);
1989 + put_cred(override_cred);
1990 +out:
1991 + return err;
1992 +}
1993 +
1994 +static int ovl_do_remove(struct dentry *dentry, bool is_dir)
1995 +{
1996 + int err;
1997 + enum ovl_path_type type;
1998 + struct path realpath;
1999 + struct dentry *upperdir;
2000 +
2001 + err = ovl_copy_up(dentry->d_parent);
2002 + if (err)
2003 + return err;
2004 +
2005 + upperdir = ovl_dentry_upper(dentry->d_parent);
2006 + mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
2007 + type = ovl_path_real(dentry, &realpath);
2008 + if (type != OVL_PATH_LOWER) {
2009 + err = -ESTALE;
2010 + if (realpath.dentry->d_parent != upperdir)
2011 + goto out_d_drop;
2012 +
2013 + if (is_dir)
2014 + err = vfs_rmdir(upperdir->d_inode, realpath.dentry);
2015 + else
2016 + err = vfs_unlink(upperdir->d_inode, realpath.dentry);
2017 + if (err)
2018 + goto out_d_drop;
2019 +
2020 + ovl_dentry_version_inc(dentry->d_parent);
2021 + }
2022 +
2023 + if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry))
2024 + err = ovl_whiteout(upperdir, dentry);
2025 +
2026 + /*
2027 + * Keeping this dentry hashed would mean having to release
2028 + * upperpath/lowerpath, which could only be done if we are the
2029 + * sole user of this dentry. Too tricky... Just unhash for
2030 + * now.
2031 + */
2032 +out_d_drop:
2033 + d_drop(dentry);
2034 + mutex_unlock(&upperdir->d_inode->i_mutex);
2035 +
2036 + return err;
2037 +}
2038 +
2039 +static int ovl_unlink(struct inode *dir, struct dentry *dentry)
2040 +{
2041 + return ovl_do_remove(dentry, false);
2042 +}
2043 +
2044 +static int ovl_check_empty_dir(struct dentry *dentry)
2045 +{
2046 + int err;
2047 + struct path lowerpath;
2048 + struct path upperpath;
2049 + struct ovl_cache_entry *p;
2050 + LIST_HEAD(list);
2051 + struct ovl_readdir_data rdd = { .list = &list };
2052 +
2053 + ovl_path_upper(dentry, &upperpath);
2054 + ovl_path_lower(dentry, &lowerpath);
2055 +
2056 + err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd);
2057 + if (err)
2058 + return err;
2059 +
2060 + err = 0;
2061 +
2062 + list_for_each_entry(p, &list, l_node) {
2063 + if (p->is_whiteout)
2064 + continue;
2065 +
2066 + if (p->name[0] == '.') {
2067 + if (p->len == 1)
2068 + continue;
2069 + if (p->len == 2 && p->name[1] == '.')
2070 + continue;
2071 + }
2072 + err = -ENOTEMPTY;
2073 + break;
2074 + }
2075 +
2076 + ovl_cache_free(&list);
2077 +
2078 + return err;
2079 +}
2080 +
2081 +static int ovl_unlink_whiteout(void *buf, const char *name, int namelen,
2082 + loff_t offset, u64 ino, unsigned int d_type)
2083 +{
2084 + struct ovl_readdir_data *rdd = buf;
2085 +
2086 + rdd->count++;
2087 + /* check d_type to filter out "." and ".." */
2088 + if (d_type == DT_LNK) {
2089 + struct dentry *dentry;
2090 +
2091 + dentry = lookup_one_len(name, rdd->dir, namelen);
2092 + if (IS_ERR(dentry)) {
2093 + rdd->err = PTR_ERR(dentry);
2094 + } else {
2095 + rdd->err = vfs_unlink(rdd->dir->d_inode, dentry);
2096 + dput(dentry);
2097 + }
2098 + }
2099 +
2100 + return rdd->err;
2101 +}
2102 +
2103 +static int ovl_remove_whiteouts(struct dentry *dentry)
2104 +{
2105 + struct path upperpath;
2106 + struct ovl_readdir_data rdd = { .list = NULL };
2107 +
2108 + ovl_path_upper(dentry, &upperpath);
2109 + rdd.dir = upperpath.dentry;
2110 +
2111 + return ovl_dir_read(&upperpath, &rdd, ovl_unlink_whiteout);
2112 +}
2113 +
2114 +static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
2115 +{
2116 + int err;
2117 + enum ovl_path_type type;
2118 +
2119 + type = ovl_path_type(dentry);
2120 + if (type != OVL_PATH_UPPER) {
2121 + err = ovl_check_empty_dir(dentry);
2122 + if (err)
2123 + return err;
2124 +
2125 + if (type == OVL_PATH_MERGE) {
2126 + err = ovl_remove_whiteouts(dentry);
2127 + if (err)
2128 + return err;
2129 + }
2130 + }
2131 +
2132 + return ovl_do_remove(dentry, true);
2133 +}
2134 +
2135 +static int ovl_link(struct dentry *old, struct inode *newdir,
2136 + struct dentry *new)
2137 +{
2138 + int err;
2139 + struct dentry *olddentry;
2140 + struct dentry *newdentry;
2141 + struct dentry *upperdir;
2142 +
2143 + err = ovl_copy_up(old);
2144 + if (err)
2145 + goto out;
2146 +
2147 + err = ovl_copy_up(new->d_parent);
2148 + if (err)
2149 + goto out;
2150 +
2151 + upperdir = ovl_dentry_upper(new->d_parent);
2152 + mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
2153 + newdentry = ovl_lookup_create(upperdir, new);
2154 + err = PTR_ERR(newdentry);
2155 + if (IS_ERR(newdentry))
2156 + goto out_unlock;
2157 +
2158 + olddentry = ovl_dentry_upper(old);
2159 + err = vfs_link(olddentry, upperdir->d_inode, newdentry);
2160 + if (!err) {
2161 + ovl_dentry_version_inc(new->d_parent);
2162 + ovl_dentry_update(new, newdentry);
2163 +
2164 + ihold(old->d_inode);
2165 + d_instantiate(new, old->d_inode);
2166 + } else {
2167 + dput(newdentry);
2168 + }
2169 +out_unlock:
2170 + mutex_unlock(&upperdir->d_inode->i_mutex);
2171 +out:
2172 + return err;
2173 +
2174 +}
2175 +
2176 +static int ovl_rename(struct inode *olddir, struct dentry *old,
2177 + struct inode *newdir, struct dentry *new)
2178 +{
2179 + int err;
2180 + enum ovl_path_type old_type;
2181 + struct dentry *old_upperdir;
2182 + struct dentry *new_upperdir;
2183 + struct dentry *olddentry;
2184 + struct dentry *newdentry;
2185 + struct dentry *trap;
2186 + bool is_dir = S_ISDIR(old->d_inode->i_mode);
2187 +
2188 + /* Don't copy up directory trees */
2189 + old_type = ovl_path_type(old);
2190 + if (old_type != OVL_PATH_UPPER && is_dir)
2191 + return -EXDEV;
2192 +
2193 + if (new->d_inode) {
2194 + enum ovl_path_type new_type;
2195 +
2196 + new_type = ovl_path_type(new);
2197 +
2198 + if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) {
2199 + if (ovl_dentry_lower(old)->d_inode ==
2200 + ovl_dentry_lower(new)->d_inode)
2201 + return 0;
2202 + }
2203 + if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) {
2204 + if (ovl_dentry_upper(old)->d_inode ==
2205 + ovl_dentry_upper(new)->d_inode)
2206 + return 0;
2207 + }
2208 +
2209 + if (new_type != OVL_PATH_UPPER &&
2210 + S_ISDIR(new->d_inode->i_mode)) {
2211 + err = ovl_check_empty_dir(new);
2212 + if (err)
2213 + return err;
2214 +
2215 + if (new_type == OVL_PATH_MERGE) {
2216 + err = ovl_remove_whiteouts(new);
2217 + if (err)
2218 + return err;
2219 + }
2220 + }
2221 + }
2222 +
2223 + err = ovl_copy_up(old);
2224 + if (err)
2225 + return err;
2226 +
2227 + err = ovl_copy_up(new->d_parent);
2228 + if (err)
2229 + return err;
2230 +
2231 + old_upperdir = ovl_dentry_upper(old->d_parent);
2232 + new_upperdir = ovl_dentry_upper(new->d_parent);
2233 +
2234 + trap = lock_rename(new_upperdir, old_upperdir);
2235 +
2236 + olddentry = ovl_dentry_upper(old);
2237 + newdentry = ovl_dentry_upper(new);
2238 + if (newdentry) {
2239 + dget(newdentry);
2240 + } else {
2241 + newdentry = ovl_lookup_create(new_upperdir, new);
2242 + err = PTR_ERR(newdentry);
2243 + if (IS_ERR(newdentry))
2244 + goto out_unlock;
2245 + }
2246 +
2247 + err = -ESTALE;
2248 + if (olddentry->d_parent != old_upperdir)
2249 + goto out_dput;
2250 + if (newdentry->d_parent != new_upperdir)
2251 + goto out_dput;
2252 + if (olddentry == trap)
2253 + goto out_dput;
2254 + if (newdentry == trap)
2255 + goto out_dput;
2256 +
2257 + err = vfs_rename(old_upperdir->d_inode, olddentry,
2258 + new_upperdir->d_inode, newdentry);
2259 +
2260 + if (!err) {
2261 + bool old_opaque = ovl_dentry_is_opaque(old);
2262 + bool new_opaque = ovl_dentry_is_opaque(new);
2263 +
2264 + if (ovl_path_type(new) != OVL_PATH_UPPER)
2265 + new_opaque = true;
2266 +
2267 + if (old_type != OVL_PATH_UPPER || old_opaque)
2268 + err = ovl_whiteout(old_upperdir, old);
2269 + if (!err && is_dir) {
2270 + if (old_opaque && !new_opaque) {
2271 + ovl_remove_opaque(olddentry);
2272 + ovl_dentry_set_opaque(old, false);
2273 + }
2274 + if (!old_opaque && new_opaque) {
2275 + err = ovl_set_opaque(olddentry);
2276 + ovl_dentry_set_opaque(old, true);
2277 + }
2278 + }
2279 + ovl_dentry_version_inc(old->d_parent);
2280 + ovl_dentry_version_inc(new->d_parent);
2281 + }
2282 +
2283 +out_dput:
2284 + dput(newdentry);
2285 +out_unlock:
2286 + unlock_rename(new_upperdir, old_upperdir);
2287 + return err;
2288 +}
2289 +
2290 +static bool ovl_is_private_xattr(const char *name)
2291 +{
2292 + return strncmp(name, "trusted.overlay.", 14) == 0;
2293 +}
2294 +
2295 +static int ovl_setxattr(struct dentry *dentry, const char *name,
2296 + const void *value, size_t size, int flags)
2297 +{
2298 + int err;
2299 + struct dentry *upperdentry;
2300 +
2301 + if (ovl_is_private_xattr(name))
2302 + return -EPERM;
2303 +
2304 + err = ovl_copy_up(dentry);
2305 + if (err)
2306 + return err;
2307 +
2308 + upperdentry = ovl_dentry_upper(dentry);
2309 + return vfs_setxattr(upperdentry, name, value, size, flags);
2310 +}
2311 +
2312 +static ssize_t ovl_getxattr(struct dentry *dentry, const char *name,
2313 + void *value, size_t size)
2314 +{
2315 + if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
2316 + ovl_is_private_xattr(name))
2317 + return -ENODATA;
2318 +
2319 + return vfs_getxattr(ovl_dentry_real(dentry), name, value, size);
2320 +}
2321 +
2322 +static ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
2323 +{
2324 + ssize_t res;
2325 + int off;
2326 +
2327 + res = vfs_listxattr(ovl_dentry_real(dentry), list, size);
2328 + if (res <= 0 || size == 0)
2329 + return res;
2330 +
2331 + if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE)
2332 + return res;
2333 +
2334 + /* filter out private xattrs */
2335 + for (off = 0; off < res;) {
2336 + char *s = list + off;
2337 + size_t slen = strlen(s) + 1;
2338 +
2339 + BUG_ON(off + slen > res);
2340 +
2341 + if (ovl_is_private_xattr(s)) {
2342 + res -= slen;
2343 + memmove(s, s + slen, res - off);
2344 + } else {
2345 + off += slen;
2346 + }
2347 + }
2348 +
2349 + return res;
2350 +}
2351 +
2352 +static int ovl_removexattr(struct dentry *dentry, const char *name)
2353 +{
2354 + int err;
2355 + struct path realpath;
2356 + enum ovl_path_type type;
2357 +
2358 + if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
2359 + ovl_is_private_xattr(name))
2360 + return -ENODATA;
2361 +
2362 + type = ovl_path_real(dentry, &realpath);
2363 + if (type == OVL_PATH_LOWER) {
2364 + err = vfs_getxattr(realpath.dentry, name, NULL, 0);
2365 + if (err < 0)
2366 + return err;
2367 +
2368 + err = ovl_copy_up(dentry);
2369 + if (err)
2370 + return err;
2371 +
2372 + ovl_path_upper(dentry, &realpath);
2373 + }
2374 +
2375 + return vfs_removexattr(realpath.dentry, name);
2376 +}
2377 +
2378 +static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type,
2379 + struct dentry *realdentry)
2380 +{
2381 + if (type != OVL_PATH_LOWER)
2382 + return false;
2383 +
2384 + if (special_file(realdentry->d_inode->i_mode))
2385 + return false;
2386 +
2387 + if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
2388 + return false;
2389 +
2390 + return true;
2391 +}
2392 +
2393 +static struct file *ovl_open(struct dentry *dentry, int flags,
2394 + const struct cred *cred)
2395 +{
2396 + int err;
2397 + struct path realpath;
2398 + enum ovl_path_type type;
2399 +
2400 + type = ovl_path_real(dentry, &realpath);
2401 + if (ovl_open_need_copy_up(flags, type, realpath.dentry)) {
2402 + if (flags & O_TRUNC)
2403 + err = ovl_copy_up_truncate(dentry, 0);
2404 + else
2405 + err = ovl_copy_up(dentry);
2406 + if (err)
2407 + return ERR_PTR(err);
2408 +
2409 + ovl_path_upper(dentry, &realpath);
2410 + }
2411 +
2412 + return vfs_open(&realpath, flags, cred);
2413 +}
2414 +
2415 +static const struct inode_operations ovl_dir_inode_operations = {
2416 + .lookup = ovl_lookup,
2417 + .mkdir = ovl_mkdir,
2418 + .symlink = ovl_symlink,
2419 + .unlink = ovl_unlink,
2420 + .rmdir = ovl_rmdir,
2421 + .rename = ovl_rename,
2422 + .link = ovl_link,
2423 + .setattr = ovl_setattr,
2424 + .create = ovl_create,
2425 + .mknod = ovl_mknod,
2426 + .permission = ovl_permission,
2427 + .getattr = ovl_dir_getattr,
2428 + .setxattr = ovl_setxattr,
2429 + .getxattr = ovl_getxattr,
2430 + .listxattr = ovl_listxattr,
2431 + .removexattr = ovl_removexattr,
2432 +};
2433 +
2434 +static const struct inode_operations ovl_file_inode_operations = {
2435 + .setattr = ovl_setattr,
2436 + .permission = ovl_permission,
2437 + .getattr = ovl_getattr,
2438 + .setxattr = ovl_setxattr,
2439 + .getxattr = ovl_getxattr,
2440 + .listxattr = ovl_listxattr,
2441 + .removexattr = ovl_removexattr,
2442 + .open = ovl_open,
2443 +};
2444 +
2445 +static const struct inode_operations ovl_symlink_inode_operations = {
2446 + .setattr = ovl_setattr,
2447 + .follow_link = ovl_follow_link,
2448 + .put_link = ovl_put_link,
2449 + .readlink = ovl_readlink,
2450 + .getattr = ovl_getattr,
2451 + .setxattr = ovl_setxattr,
2452 + .getxattr = ovl_getxattr,
2453 + .listxattr = ovl_listxattr,
2454 + .removexattr = ovl_removexattr,
2455 +};
2456 +
2457 +static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode,
2458 + struct ovl_entry *oe)
2459 +{
2460 + struct inode *inode;
2461 +
2462 + inode = new_inode(sb);
2463 + if (!inode)
2464 + return NULL;
2465 +
2466 + mode &= S_IFMT;
2467 +
2468 + inode->i_ino = get_next_ino();
2469 + inode->i_mode = mode;
2470 + inode->i_flags |= S_NOATIME | S_NOCMTIME;
2471 +
2472 + switch (mode) {
2473 + case S_IFDIR:
2474 + inode->i_private = oe;
2475 + inode->i_op = &ovl_dir_inode_operations;
2476 + inode->i_fop = &ovl_dir_operations;
2477 + break;
2478 +
2479 + case S_IFLNK:
2480 + inode->i_op = &ovl_symlink_inode_operations;
2481 + break;
2482 +
2483 + case S_IFREG:
2484 + case S_IFSOCK:
2485 + case S_IFBLK:
2486 + case S_IFCHR:
2487 + case S_IFIFO:
2488 + inode->i_op = &ovl_file_inode_operations;
2489 + break;
2490 +
2491 + default:
2492 + WARN(1, "illegal file type: %i\n", mode);
2493 + inode = NULL;
2494 + }
2495 +
2496 + return inode;
2497 +
2498 +}
2499 +
2500 +static void ovl_put_super(struct super_block *sb)
2501 +{
2502 + struct ovl_fs *ufs = sb->s_fs_info;
2503 +
2504 + if (!(sb->s_flags & MS_RDONLY))
2505 + mnt_drop_write(ufs->upper_mnt);
2506 +
2507 + mntput(ufs->upper_mnt);
2508 + mntput(ufs->lower_mnt);
2509 +
2510 + kfree(ufs);
2511 +}
2512 +
2513 +static int ovl_remount_fs(struct super_block *sb, int *flagsp, char *data)
2514 +{
2515 + int flags = *flagsp;
2516 + struct ovl_fs *ufs = sb->s_fs_info;
2517 +
2518 + /* When remounting rw or ro, we need to adjust the write access to the
2519 + * upper fs.
2520 + */
2521 + if (((flags ^ sb->s_flags) & MS_RDONLY) == 0)
2522 + /* No change to readonly status */
2523 + return 0;
2524 +
2525 + if (flags & MS_RDONLY) {
2526 + mnt_drop_write(ufs->upper_mnt);
2527 + return 0;
2528 + } else
2529 + return mnt_want_write(ufs->upper_mnt);
2530 +}
2531 +
2532 +/**
2533 + * ovl_statfs
2534 + * @sb: The overlayfs super block
2535 + * @buf: The struct kstatfs to fill in with stats
2536 + *
2537 + * Get the filesystem statistics. As writes always target the upper layer
2538 + * filesystem pass the statfs to the same filesystem.
2539 + */
2540 +static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
2541 +{
2542 + struct dentry *root_dentry = dentry->d_sb->s_root;
2543 + struct path path;
2544 + ovl_path_upper(root_dentry, &path);
2545 +
2546 + if (!path.dentry->d_sb->s_op->statfs)
2547 + return -ENOSYS;
2548 + return path.dentry->d_sb->s_op->statfs(path.dentry, buf);
2549 +}
2550 +
2551 +static const struct super_operations ovl_super_operations = {
2552 + .put_super = ovl_put_super,
2553 + .remount_fs = ovl_remount_fs,
2554 + .statfs = ovl_statfs,
2555 +};
2556 +
2557 +struct ovl_config {
2558 + char *lowerdir;
2559 + char *upperdir;
2560 +};
2561 +
2562 +enum {
2563 + Opt_lowerdir,
2564 + Opt_upperdir,
2565 + Opt_err,
2566 +};
2567 +
2568 +static const match_table_t ovl_tokens = {
2569 + {Opt_lowerdir, "lowerdir=%s"},
2570 + {Opt_upperdir, "upperdir=%s"},
2571 + {Opt_err, NULL}
2572 +};
2573 +
2574 +static int ovl_parse_opt(char *opt, struct ovl_config *config)
2575 +{
2576 + char *p;
2577 +
2578 + config->upperdir = NULL;
2579 + config->lowerdir = NULL;
2580 +
2581 + while ((p = strsep(&opt, ",")) != NULL) {
2582 + int token;
2583 + substring_t args[MAX_OPT_ARGS];
2584 +
2585 + if (!*p)
2586 + continue;
2587 +
2588 + token = match_token(p, ovl_tokens, args);
2589 + switch (token) {
2590 + case Opt_upperdir:
2591 + kfree(config->upperdir);
2592 + config->upperdir = match_strdup(&args[0]);
2593 + if (!config->upperdir)
2594 + return -ENOMEM;
2595 + break;
2596 +
2597 + case Opt_lowerdir:
2598 + kfree(config->lowerdir);
2599 + config->lowerdir = match_strdup(&args[0]);
2600 + if (!config->lowerdir)
2601 + return -ENOMEM;
2602 + break;
2603 +
2604 + default:
2605 + return -EINVAL;
2606 + }
2607 + }
2608 + return 0;
2609 +}
2610 +
2611 +static int ovl_fill_super(struct super_block *sb, void *data, int silent)
2612 +{
2613 + struct path lowerpath;
2614 + struct path upperpath;
2615 + struct inode *root_inode;
2616 + struct dentry *root_dentry;
2617 + struct ovl_entry *oe;
2618 + struct ovl_fs *ufs;
2619 + struct ovl_config config;
2620 + int err;
2621 +
2622 + err = ovl_parse_opt((char *) data, &config);
2623 + if (err)
2624 + goto out;
2625 +
2626 + err = -EINVAL;
2627 + if (!config.upperdir || !config.lowerdir) {
2628 + printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n");
2629 + goto out_free_config;
2630 + }
2631 +
2632 + err = -ENOMEM;
2633 + ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL);
2634 + if (!ufs)
2635 + goto out_free_config;
2636 +
2637 + oe = ovl_alloc_entry();
2638 + if (oe == NULL)
2639 + goto out_free_ufs;
2640 +
2641 + root_inode = ovl_new_inode(sb, S_IFDIR, oe);
2642 + if (!root_inode)
2643 + goto out_free_oe;
2644 +
2645 + err = kern_path(config.upperdir, LOOKUP_FOLLOW, &upperpath);
2646 + if (err)
2647 + goto out_put_root;
2648 +
2649 + err = kern_path(config.lowerdir, LOOKUP_FOLLOW, &lowerpath);
2650 + if (err)
2651 + goto out_put_upperpath;
2652 +
2653 + err = -ENOTDIR;
2654 + if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) ||
2655 + !S_ISDIR(lowerpath.dentry->d_inode->i_mode))
2656 + goto out_put_lowerpath;
2657 +
2658 + ufs->upper_mnt = clone_private_mount(&upperpath);
2659 + err = PTR_ERR(ufs->upper_mnt);
2660 + if (IS_ERR(ufs->upper_mnt)) {
2661 + printk(KERN_ERR "overlayfs: failed to clone upperpath\n");
2662 + goto out_put_lowerpath;
2663 + }
2664 +
2665 + ufs->lower_mnt = clone_private_mount(&lowerpath);
2666 + err = PTR_ERR(ufs->lower_mnt);
2667 + if (IS_ERR(ufs->lower_mnt)) {
2668 + printk(KERN_ERR "overlayfs: failed to clone lowerpath\n");
2669 + goto out_put_upper_mnt;
2670 + }
2671 +
2672 + if (!(sb->s_flags & MS_RDONLY)) {
2673 + err = mnt_want_write(ufs->upper_mnt);
2674 + if (err)
2675 + goto out_put_lower_mnt;
2676 + }
2677 +
2678 + err = -ENOMEM;
2679 + root_dentry = d_alloc_root(root_inode);
2680 + if (!root_dentry)
2681 + goto out_drop_write;
2682 +
2683 + mntput(upperpath.mnt);
2684 + mntput(lowerpath.mnt);
2685 +
2686 + oe->__upperdentry = upperpath.dentry;
2687 + oe->lowerdentry = lowerpath.dentry;
2688 +
2689 + root_dentry->d_fsdata = oe;
2690 + root_dentry->d_op = &ovl_dentry_operations;
2691 +
2692 + sb->s_op = &ovl_super_operations;
2693 + sb->s_root = root_dentry;
2694 + sb->s_fs_info = ufs;
2695 +
2696 + return 0;
2697 +
2698 +out_drop_write:
2699 + if (!(sb->s_flags & MS_RDONLY))
2700 + mnt_drop_write(ufs->upper_mnt);
2701 +out_put_lower_mnt:
2702 + mntput(ufs->lower_mnt);
2703 +out_put_upper_mnt:
2704 + mntput(ufs->upper_mnt);
2705 +out_put_lowerpath:
2706 + path_put(&lowerpath);
2707 +out_put_upperpath:
2708 + path_put(&upperpath);
2709 +out_put_root:
2710 + iput(root_inode);
2711 +out_free_oe:
2712 + kfree(oe);
2713 +out_free_ufs:
2714 + kfree(ufs);
2715 +out_free_config:
2716 + kfree(config.lowerdir);
2717 + kfree(config.upperdir);
2718 +out:
2719 + return err;
2720 +}
2721 +
2722 +static int ovl_get_sb(struct file_system_type *fs_type,
2723 + int flags, const char *dev_name,
2724 + void *raw_data, struct vfsmount *mnt)
2725 +{
2726 + return get_sb_nodev(fs_type, flags, raw_data, ovl_fill_super, mnt);
2727 +}
2728 +
2729 +static struct file_system_type ovl_fs_type = {
2730 + .owner = THIS_MODULE,
2731 + .name = "overlayfs",
2732 + .get_sb = ovl_get_sb,
2733 + .kill_sb = kill_anon_super,
2734 +};
2735 +
2736 +static int __init ovl_init(void)
2737 +{
2738 + return register_filesystem(&ovl_fs_type);
2739 +}
2740 +
2741 +static void __exit ovl_exit(void)
2742 +{
2743 + unregister_filesystem(&ovl_fs_type);
2744 +}
2745 +
2746 +module_init(ovl_init);
2747 +module_exit(ovl_exit);
2748 --- a/fs/splice.c
2749 +++ b/fs/splice.c
2750 @@ -1296,6 +1296,7 @@ long do_splice_direct(struct file *in, l
2751
2752 return ret;
2753 }
2754 +EXPORT_SYMBOL(do_splice_direct);
2755
2756 static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
2757 struct pipe_inode_info *opipe,
2758 --- a/include/linux/fs.h
2759 +++ b/include/linux/fs.h
2760 @@ -1587,6 +1587,7 @@ struct inode_operations {
2761 void (*truncate_range)(struct inode *, loff_t, loff_t);
2762 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
2763 u64 len);
2764 + struct file *(*open)(struct dentry *, int flags, const struct cred *);
2765 } ____cacheline_aligned;
2766
2767 struct seq_file;
2768 @@ -1990,6 +1991,7 @@ extern int do_fallocate(struct file *fil
2769 extern long do_sys_open(int dfd, const char __user *filename, int flags,
2770 int mode);
2771 extern struct file *filp_open(const char *, int, int);
2772 +extern struct file *vfs_open(struct path *, int flags, const struct cred *);
2773 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
2774 const struct cred *);
2775 extern int filp_close(struct file *, fl_owner_t id);
2776 --- a/include/linux/mount.h
2777 +++ b/include/linux/mount.h
2778 @@ -100,6 +100,9 @@ extern void mnt_pin(struct vfsmount *mnt
2779 extern void mnt_unpin(struct vfsmount *mnt);
2780 extern int __mnt_is_readonly(struct vfsmount *mnt);
2781
2782 +struct path;
2783 +extern struct vfsmount *clone_private_mount(struct path *path);
2784 +
2785 extern struct vfsmount *do_kern_mount(const char *fstype, int flags,
2786 const char *name, void *data);
2787
OpenWrt SVN history