Whamcloud - gitweb
LU-14621 mdd: fix lock-tx order in mdd_xattr_merge()
[fs/lustre-release.git] / lustre / llite / pcc.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2017, DDN Storage Corporation.
24  */
25 /*
26  *
27  * Persistent Client Cache
28  *
29  * Author: Li Xi <lixi@ddn.com>
30  */
31
32 #ifndef LLITE_PCC_H
33 #define LLITE_PCC_H
34
35 #include <linux/types.h>
36 #include <linux/fs.h>
37 #include <linux/seq_file.h>
38 #include <linux/mm.h>
39 #include <uapi/linux/lustre/lustre_user.h>
40
41 extern struct kmem_cache *pcc_inode_slab;
42
43 #define LPROCFS_WR_PCC_MAX_CMD 4096
44
45 /* User/Group/Project ID */
46 struct pcc_match_id {
47         __u32                   pmi_id;
48         struct list_head        pmi_linkage;
49 };
50
51 /* wildcard file name */
52 struct pcc_match_fname {
53         char                    *pmf_name;
54         struct list_head         pmf_linkage;
55 };
56
57 enum pcc_field {
58         PCC_FIELD_UID,
59         PCC_FIELD_GID,
60         PCC_FIELD_PROJID,
61         PCC_FIELD_FNAME,
62         PCC_FIELD_MAX
63 };
64
65 struct pcc_expression {
66         enum pcc_field          pe_field;
67         struct list_head        pe_cond;
68         struct list_head        pe_linkage;
69 };
70
71 struct pcc_conjunction {
72         /* link to disjunction */
73         struct list_head        pc_linkage;
74         /* list of logical conjunction */
75         struct list_head        pc_expressions;
76 };
77
78 /**
79  * Match rule for auto PCC-cached files.
80  */
81 struct pcc_match_rule {
82         char                    *pmr_conds_str;
83         struct list_head         pmr_conds;
84 };
85
86 struct pcc_matcher {
87         __u32            pm_uid;
88         __u32            pm_gid;
89         __u32            pm_projid;
90         struct qstr     *pm_name;
91 };
92
93 enum pcc_dataset_flags {
94         PCC_DATASET_INVALID     = 0x0,
95         /* Indicate that known the file is not in PCC. */
96         PCC_DATASET_NONE        = 0x01,
97         /* Try auto attach at open, enabled by default */
98         PCC_DATASET_OPEN_ATTACH = 0x02,
99         /* Try auto attach during IO when layout refresh, enabled by default */
100         PCC_DATASET_IO_ATTACH   = 0x04,
101         /* Try auto attach at stat */
102         PCC_DATASET_STAT_ATTACH = 0x08,
103         PCC_DATASET_AUTO_ATTACH = PCC_DATASET_OPEN_ATTACH |
104                                   PCC_DATASET_IO_ATTACH |
105                                   PCC_DATASET_STAT_ATTACH,
106         /* PCC backend is only used for RW-PCC */
107         PCC_DATASET_RWPCC       = 0x10,
108         /* PCC backend is only used for RO-PCC */
109         PCC_DATASET_ROPCC       = 0x20,
110         /* PCC backend provides caching services for both RW-PCC and RO-PCC */
111         PCC_DATASET_PCC_ALL     = PCC_DATASET_RWPCC | PCC_DATASET_ROPCC,
112 };
113
114 struct pcc_dataset {
115         __u32                   pccd_rwid;       /* Archive ID */
116         __u32                   pccd_roid;       /* Readonly ID */
117         struct pcc_match_rule   pccd_rule;       /* Match rule */
118         enum pcc_dataset_flags  pccd_flags;      /* Flags of PCC backend */
119         char                    pccd_pathname[PATH_MAX]; /* full path */
120         struct path             pccd_path;       /* Root path */
121         struct list_head        pccd_linkage;  /* Linked to pccs_datasets */
122         atomic_t                pccd_refcount; /* Reference count */
123 };
124
125 struct pcc_super {
126         /* Protect pccs_datasets */
127         struct rw_semaphore      pccs_rw_sem;
128         /* List of datasets */
129         struct list_head         pccs_datasets;
130         /* creds of process who forced instantiation of super block */
131         const struct cred       *pccs_cred;
132         /*
133          * Gobal PCC Generation: it will be increased once the configuration
134          * for PCC is changed, i.e. add or delete a PCC backend, modify the
135          * parameters for PCC.
136          */
137         __u64                    pccs_generation;
138 };
139
140 struct pcc_inode {
141         struct ll_inode_info    *pcci_lli;
142         /* Cache path on local file system */
143         struct path              pcci_path;
144         /*
145          * If reference count is 0, then the cache is not inited, if 1, then
146          * no one is using it.
147          */
148         atomic_t                 pcci_refcount;
149         /* Whether readonly or readwrite PCC */
150         enum lu_pcc_type         pcci_type;
151         /* Whether the inode attr is cached locally */
152         bool                     pcci_attr_valid;
153         /* Layout generation */
154         __u32                    pcci_layout_gen;
155         /*
156          * How many IOs are on going on this cached object. Layout can be
157          * changed only if there is no active IO.
158          */
159         atomic_t                 pcci_active_ios;
160         /* Waitq - wait for PCC I/O completion. */
161         wait_queue_head_t        pcci_waitq;
162 };
163
164 struct pcc_file {
165         /* Opened cache file */
166         struct file             *pccf_file;
167         /* Whether readonly or readwrite PCC */
168         enum lu_pcc_type         pccf_type;
169 };
170
171 enum pcc_io_type {
172         /* read system call */
173         PIT_READ = 1,
174         /* write system call */
175         PIT_WRITE,
176         /* truncate, utime system calls */
177         PIT_SETATTR,
178         /* stat system call */
179         PIT_GETATTR,
180         /* mmap write handling */
181         PIT_PAGE_MKWRITE,
182         /* page fault handling */
183         PIT_FAULT,
184         /* fsync system call handling */
185         PIT_FSYNC,
186 #ifdef HAVE_DEFAULT_FILE_SPLICE_READ_EXPORT
187         /* splice_read system call */
188         PIT_SPLICE_READ,
189 #endif
190         /* open system call */
191         PIT_OPEN
192 };
193
194 enum pcc_cmd_type {
195         PCC_ADD_DATASET = 0,
196         PCC_DEL_DATASET,
197         PCC_CLEAR_ALL,
198 };
199
200 struct pcc_cmd {
201         enum pcc_cmd_type                        pccc_cmd;
202         char                                    *pccc_pathname;
203         union {
204                 struct pcc_cmd_add {
205                         __u32                    pccc_rwid;
206                         __u32                    pccc_roid;
207                         struct list_head         pccc_conds;
208                         char                    *pccc_conds_str;
209                         enum pcc_dataset_flags   pccc_flags;
210                 } pccc_add;
211                 struct pcc_cmd_del {
212                         __u32                    pccc_pad;
213                 } pccc_del;
214         } u;
215 };
216
217 struct pcc_create_attach {
218         struct pcc_dataset *pca_dataset;
219         struct dentry *pca_dentry;
220 };
221
222 int pcc_super_init(struct pcc_super *super);
223 void pcc_super_fini(struct pcc_super *super);
224 int pcc_cmd_handle(char *buffer, unsigned long count,
225                    struct pcc_super *super);
226 int pcc_super_dump(struct pcc_super *super, struct seq_file *m);
227 int pcc_readwrite_attach(struct file *file, struct inode *inode,
228                          __u32 arch_id);
229 int pcc_readwrite_attach_fini(struct file *file, struct inode *inode,
230                               __u32 gen, bool lease_broken, int rc,
231                               bool attached);
232 int pcc_ioctl_detach(struct inode *inode, __u32 opt);
233 int pcc_ioctl_state(struct file *file, struct inode *inode,
234                     struct lu_pcc_state *state);
235 void pcc_file_init(struct pcc_file *pccf);
236 int pcc_file_open(struct inode *inode, struct file *file);
237 void pcc_file_release(struct inode *inode, struct file *file);
238 ssize_t pcc_file_read_iter(struct kiocb *iocb, struct iov_iter *iter,
239                            bool *cached);
240 ssize_t pcc_file_write_iter(struct kiocb *iocb, struct iov_iter *iter,
241                             bool *cached);
242 int pcc_inode_getattr(struct inode *inode, u32 request_mask,
243                       unsigned int flags, bool *cached);
244 int pcc_inode_setattr(struct inode *inode, struct iattr *attr, bool *cached);
245 #ifdef HAVE_DEFAULT_FILE_SPLICE_READ_EXPORT
246 ssize_t pcc_file_splice_read(struct file *in_file, loff_t *ppos,
247                              struct pipe_inode_info *pipe, size_t count,
248                              unsigned int flags);
249 #endif
250 int pcc_fsync(struct file *file, loff_t start, loff_t end,
251               int datasync, bool *cached);
252 int pcc_file_mmap(struct file *file, struct vm_area_struct *vma, bool *cached);
253 void pcc_vm_open(struct vm_area_struct *vma);
254 void pcc_vm_close(struct vm_area_struct *vma);
255 int pcc_fault(struct vm_area_struct *mva, struct vm_fault *vmf, bool *cached);
256 int pcc_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
257                      bool *cached);
258 int pcc_inode_create(struct super_block *sb, struct pcc_dataset *dataset,
259                      struct lu_fid *fid, struct dentry **pcc_dentry);
260 int pcc_inode_create_fini(struct inode *inode, struct pcc_create_attach *pca);
261 void pcc_create_attach_cleanup(struct super_block *sb,
262                                struct pcc_create_attach *pca);
263 struct pcc_dataset *pcc_dataset_match_get(struct pcc_super *super,
264                                           struct pcc_matcher *matcher);
265 void pcc_dataset_put(struct pcc_dataset *dataset);
266 void pcc_inode_free(struct inode *inode);
267 void pcc_layout_invalidate(struct inode *inode);
268 #endif /* LLITE_PCC_H */