1 // SPDX-License-Identifier: GPL-2.0-only
3 * Common helpers for stackable filesystems and backing files.
5 * Forked from fs/overlayfs/file.c.
7 * Copyright (C) 2017 Red Hat, Inc.
8 * Copyright (C) 2023 CTERA Networks.
12 #include <linux/backing-file.h>
13 #include <linux/splice.h>
19 * backing_file_open - open a backing file for kernel internal use
20 * @user_path: path that the user reuqested to open
22 * @real_path: path of the backing file
23 * @cred: credentials for open
25 * Open a backing file for a stackable filesystem (e.g., overlayfs).
26 * @user_path may be on the stackable filesystem and @real_path on the
27 * underlying filesystem. In this case, we want to be able to return the
28 * @user_path of the stackable filesystem. This is done by embedding the
29 * returned file into a container structure that also stores the stacked
30 * file's path, which can be retrieved using backing_file_user_path().
32 struct file
*backing_file_open(const struct path
*user_path
, int flags
,
33 const struct path
*real_path
,
34 const struct cred
*cred
)
39 f
= alloc_empty_backing_file(flags
, cred
);
44 *backing_file_user_path(f
) = *user_path
;
45 error
= vfs_open(real_path
, f
);
53 EXPORT_SYMBOL_GPL(backing_file_open
);
58 struct kiocb
*orig_iocb
;
59 /* used for aio completion */
60 void (*end_write
)(struct file
*);
61 struct work_struct work
;
65 static struct kmem_cache
*backing_aio_cachep
;
67 #define BACKING_IOCB_MASK \
68 (IOCB_NOWAIT | IOCB_HIPRI | IOCB_DSYNC | IOCB_SYNC | IOCB_APPEND)
70 static rwf_t
iocb_to_rw_flags(int flags
)
72 return (__force rwf_t
)(flags
& BACKING_IOCB_MASK
);
75 static void backing_aio_put(struct backing_aio
*aio
)
77 if (refcount_dec_and_test(&aio
->ref
)) {
78 fput(aio
->iocb
.ki_filp
);
79 kmem_cache_free(backing_aio_cachep
, aio
);
83 static void backing_aio_cleanup(struct backing_aio
*aio
, long res
)
85 struct kiocb
*iocb
= &aio
->iocb
;
86 struct kiocb
*orig_iocb
= aio
->orig_iocb
;
89 aio
->end_write(orig_iocb
->ki_filp
);
91 orig_iocb
->ki_pos
= iocb
->ki_pos
;
95 static void backing_aio_rw_complete(struct kiocb
*iocb
, long res
)
97 struct backing_aio
*aio
= container_of(iocb
, struct backing_aio
, iocb
);
98 struct kiocb
*orig_iocb
= aio
->orig_iocb
;
100 if (iocb
->ki_flags
& IOCB_WRITE
)
101 kiocb_end_write(iocb
);
103 backing_aio_cleanup(aio
, res
);
104 orig_iocb
->ki_complete(orig_iocb
, res
);
107 static void backing_aio_complete_work(struct work_struct
*work
)
109 struct backing_aio
*aio
= container_of(work
, struct backing_aio
, work
);
111 backing_aio_rw_complete(&aio
->iocb
, aio
->res
);
114 static void backing_aio_queue_completion(struct kiocb
*iocb
, long res
)
116 struct backing_aio
*aio
= container_of(iocb
, struct backing_aio
, iocb
);
119 * Punt to a work queue to serialize updates of mtime/size.
122 INIT_WORK(&aio
->work
, backing_aio_complete_work
);
123 queue_work(file_inode(aio
->orig_iocb
->ki_filp
)->i_sb
->s_dio_done_wq
,
127 static int backing_aio_init_wq(struct kiocb
*iocb
)
129 struct super_block
*sb
= file_inode(iocb
->ki_filp
)->i_sb
;
131 if (sb
->s_dio_done_wq
)
134 return sb_init_dio_done_wq(sb
);
138 ssize_t
backing_file_read_iter(struct file
*file
, struct iov_iter
*iter
,
139 struct kiocb
*iocb
, int flags
,
140 struct backing_file_ctx
*ctx
)
142 struct backing_aio
*aio
= NULL
;
143 const struct cred
*old_cred
;
146 if (WARN_ON_ONCE(!(file
->f_mode
& FMODE_BACKING
)))
149 if (!iov_iter_count(iter
))
152 if (iocb
->ki_flags
& IOCB_DIRECT
&&
153 !(file
->f_mode
& FMODE_CAN_ODIRECT
))
156 old_cred
= override_creds(ctx
->cred
);
157 if (is_sync_kiocb(iocb
)) {
158 rwf_t rwf
= iocb_to_rw_flags(flags
);
160 ret
= vfs_iter_read(file
, iter
, &iocb
->ki_pos
, rwf
);
163 aio
= kmem_cache_zalloc(backing_aio_cachep
, GFP_KERNEL
);
167 aio
->orig_iocb
= iocb
;
168 kiocb_clone(&aio
->iocb
, iocb
, get_file(file
));
169 aio
->iocb
.ki_complete
= backing_aio_rw_complete
;
170 refcount_set(&aio
->ref
, 2);
171 ret
= vfs_iocb_iter_read(file
, &aio
->iocb
, iter
);
172 backing_aio_put(aio
);
173 if (ret
!= -EIOCBQUEUED
)
174 backing_aio_cleanup(aio
, ret
);
177 revert_creds(old_cred
);
180 ctx
->accessed(ctx
->user_file
);
184 EXPORT_SYMBOL_GPL(backing_file_read_iter
);
186 ssize_t
backing_file_write_iter(struct file
*file
, struct iov_iter
*iter
,
187 struct kiocb
*iocb
, int flags
,
188 struct backing_file_ctx
*ctx
)
190 const struct cred
*old_cred
;
193 if (WARN_ON_ONCE(!(file
->f_mode
& FMODE_BACKING
)))
196 if (!iov_iter_count(iter
))
199 ret
= file_remove_privs(ctx
->user_file
);
203 if (iocb
->ki_flags
& IOCB_DIRECT
&&
204 !(file
->f_mode
& FMODE_CAN_ODIRECT
))
208 * Stacked filesystems don't support deferred completions, don't copy
209 * this property in case it is set by the issuer.
211 flags
&= ~IOCB_DIO_CALLER_COMP
;
213 old_cred
= override_creds(ctx
->cred
);
214 if (is_sync_kiocb(iocb
)) {
215 rwf_t rwf
= iocb_to_rw_flags(flags
);
217 ret
= vfs_iter_write(file
, iter
, &iocb
->ki_pos
, rwf
);
219 ctx
->end_write(ctx
->user_file
);
221 struct backing_aio
*aio
;
223 ret
= backing_aio_init_wq(iocb
);
228 aio
= kmem_cache_zalloc(backing_aio_cachep
, GFP_KERNEL
);
232 aio
->orig_iocb
= iocb
;
233 aio
->end_write
= ctx
->end_write
;
234 kiocb_clone(&aio
->iocb
, iocb
, get_file(file
));
235 aio
->iocb
.ki_flags
= flags
;
236 aio
->iocb
.ki_complete
= backing_aio_queue_completion
;
237 refcount_set(&aio
->ref
, 2);
238 ret
= vfs_iocb_iter_write(file
, &aio
->iocb
, iter
);
239 backing_aio_put(aio
);
240 if (ret
!= -EIOCBQUEUED
)
241 backing_aio_cleanup(aio
, ret
);
244 revert_creds(old_cred
);
248 EXPORT_SYMBOL_GPL(backing_file_write_iter
);
250 ssize_t
backing_file_splice_read(struct file
*in
, loff_t
*ppos
,
251 struct pipe_inode_info
*pipe
, size_t len
,
253 struct backing_file_ctx
*ctx
)
255 const struct cred
*old_cred
;
258 if (WARN_ON_ONCE(!(in
->f_mode
& FMODE_BACKING
)))
261 old_cred
= override_creds(ctx
->cred
);
262 ret
= vfs_splice_read(in
, ppos
, pipe
, len
, flags
);
263 revert_creds(old_cred
);
266 ctx
->accessed(ctx
->user_file
);
270 EXPORT_SYMBOL_GPL(backing_file_splice_read
);
272 ssize_t
backing_file_splice_write(struct pipe_inode_info
*pipe
,
273 struct file
*out
, loff_t
*ppos
, size_t len
,
275 struct backing_file_ctx
*ctx
)
277 const struct cred
*old_cred
;
280 if (WARN_ON_ONCE(!(out
->f_mode
& FMODE_BACKING
)))
283 ret
= file_remove_privs(ctx
->user_file
);
287 old_cred
= override_creds(ctx
->cred
);
288 file_start_write(out
);
289 ret
= iter_file_splice_write(pipe
, out
, ppos
, len
, flags
);
291 revert_creds(old_cred
);
294 ctx
->end_write(ctx
->user_file
);
298 EXPORT_SYMBOL_GPL(backing_file_splice_write
);
300 int backing_file_mmap(struct file
*file
, struct vm_area_struct
*vma
,
301 struct backing_file_ctx
*ctx
)
303 const struct cred
*old_cred
;
306 if (WARN_ON_ONCE(!(file
->f_mode
& FMODE_BACKING
)) ||
307 WARN_ON_ONCE(ctx
->user_file
!= vma
->vm_file
))
310 if (!file
->f_op
->mmap
)
313 vma_set_file(vma
, file
);
315 old_cred
= override_creds(ctx
->cred
);
316 ret
= call_mmap(vma
->vm_file
, vma
);
317 revert_creds(old_cred
);
320 ctx
->accessed(ctx
->user_file
);
324 EXPORT_SYMBOL_GPL(backing_file_mmap
);
326 static int __init
backing_aio_init(void)
328 backing_aio_cachep
= kmem_cache_create("backing_aio",
329 sizeof(struct backing_aio
),
330 0, SLAB_HWCACHE_ALIGN
, NULL
);
331 if (!backing_aio_cachep
)
336 fs_initcall(backing_aio_init
);