Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* CacheFiles extended attribute management
3 *
4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/module.h>
9#include <linux/sched.h>
10#include <linux/file.h>
11#include <linux/fs.h>
12#include <linux/fsnotify.h>
13#include <linux/quotaops.h>
14#include <linux/xattr.h>
15#include <linux/slab.h>
16#include "internal.h"
17
18static const char cachefiles_xattr_cache[] =
19 XATTR_USER_PREFIX "CacheFiles.cache";
20
21/*
22 * check the type label on an object
23 * - done using xattrs
24 */
25int cachefiles_check_object_type(struct cachefiles_object *object)
26{
27 struct dentry *dentry = object->dentry;
28 char type[3], xtype[3];
29 int ret;
30
31 ASSERT(dentry);
32 ASSERT(d_backing_inode(dentry));
33
34 if (!object->fscache.cookie)
35 strcpy(type, "C3");
36 else
37 snprintf(type, 3, "%02x", object->fscache.cookie->def->type);
38
39 _enter("%p{%s}", object, type);
40
41 /* attempt to install a type label directly */
42 ret = vfs_setxattr(dentry, cachefiles_xattr_cache, type, 2,
43 XATTR_CREATE);
44 if (ret == 0) {
45 _debug("SET"); /* we succeeded */
46 goto error;
47 }
48
49 if (ret != -EEXIST) {
50 pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
51 dentry, d_backing_inode(dentry)->i_ino,
52 -ret);
53 goto error;
54 }
55
56 /* read the current type label */
57 ret = vfs_getxattr(dentry, cachefiles_xattr_cache, xtype, 3);
58 if (ret < 0) {
59 if (ret == -ERANGE)
60 goto bad_type_length;
61
62 pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
63 dentry, d_backing_inode(dentry)->i_ino,
64 -ret);
65 goto error;
66 }
67
68 /* check the type is what we're expecting */
69 if (ret != 2)
70 goto bad_type_length;
71
72 if (xtype[0] != type[0] || xtype[1] != type[1])
73 goto bad_type;
74
75 ret = 0;
76
77error:
78 _leave(" = %d", ret);
79 return ret;
80
81bad_type_length:
82 pr_err("Cache object %lu type xattr length incorrect\n",
83 d_backing_inode(dentry)->i_ino);
84 ret = -EIO;
85 goto error;
86
87bad_type:
88 xtype[2] = 0;
89 pr_err("Cache object %pd [%lu] type %s not %s\n",
90 dentry, d_backing_inode(dentry)->i_ino,
91 xtype, type);
92 ret = -EIO;
93 goto error;
94}
95
96/*
97 * set the state xattr on a cache file
98 */
99int cachefiles_set_object_xattr(struct cachefiles_object *object,
100 struct cachefiles_xattr *auxdata)
101{
102 struct dentry *dentry = object->dentry;
103 int ret;
104
105 ASSERT(dentry);
106
107 _enter("%p,#%d", object, auxdata->len);
108
109 /* attempt to install the cache metadata directly */
110 _debug("SET #%u", auxdata->len);
111
112 clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
113 ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
114 &auxdata->type, auxdata->len,
115 XATTR_CREATE);
116 if (ret < 0 && ret != -ENOMEM)
117 cachefiles_io_error_obj(
118 object,
119 "Failed to set xattr with error %d", ret);
120
121 _leave(" = %d", ret);
122 return ret;
123}
124
125/*
126 * update the state xattr on a cache file
127 */
128int cachefiles_update_object_xattr(struct cachefiles_object *object,
129 struct cachefiles_xattr *auxdata)
130{
131 struct dentry *dentry = object->dentry;
132 int ret;
133
134 if (!dentry)
135 return -ESTALE;
136
137 _enter("%p,#%d", object, auxdata->len);
138
139 /* attempt to install the cache metadata directly */
140 _debug("SET #%u", auxdata->len);
141
142 clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
143 ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
144 &auxdata->type, auxdata->len,
145 XATTR_REPLACE);
146 if (ret < 0 && ret != -ENOMEM)
147 cachefiles_io_error_obj(
148 object,
149 "Failed to update xattr with error %d", ret);
150
151 _leave(" = %d", ret);
152 return ret;
153}
154
155/*
156 * check the consistency between the backing cache and the FS-Cache cookie
157 */
158int cachefiles_check_auxdata(struct cachefiles_object *object)
159{
160 struct cachefiles_xattr *auxbuf;
161 enum fscache_checkaux validity;
162 struct dentry *dentry = object->dentry;
163 ssize_t xlen;
164 int ret;
165
166 ASSERT(dentry);
167 ASSERT(d_backing_inode(dentry));
168 ASSERT(object->fscache.cookie->def->check_aux);
169
170 auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
171 if (!auxbuf)
172 return -ENOMEM;
173
174 xlen = vfs_getxattr(dentry, cachefiles_xattr_cache,
175 &auxbuf->type, 512 + 1);
176 ret = -ESTALE;
177 if (xlen < 1 ||
178 auxbuf->type != object->fscache.cookie->def->type)
179 goto error;
180
181 xlen--;
182 validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen,
183 i_size_read(d_backing_inode(dentry)));
184 if (validity != FSCACHE_CHECKAUX_OKAY)
185 goto error;
186
187 ret = 0;
188error:
189 kfree(auxbuf);
190 return ret;
191}
192
193/*
194 * check the state xattr on a cache file
195 * - return -ESTALE if the object should be deleted
196 */
197int cachefiles_check_object_xattr(struct cachefiles_object *object,
198 struct cachefiles_xattr *auxdata)
199{
200 struct cachefiles_xattr *auxbuf;
201 struct dentry *dentry = object->dentry;
202 int ret;
203
204 _enter("%p,#%d", object, auxdata->len);
205
206 ASSERT(dentry);
207 ASSERT(d_backing_inode(dentry));
208
209 auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
210 if (!auxbuf) {
211 _leave(" = -ENOMEM");
212 return -ENOMEM;
213 }
214
215 /* read the current type label */
216 ret = vfs_getxattr(dentry, cachefiles_xattr_cache,
217 &auxbuf->type, 512 + 1);
218 if (ret < 0) {
219 if (ret == -ENODATA)
220 goto stale; /* no attribute - power went off
221 * mid-cull? */
222
223 if (ret == -ERANGE)
224 goto bad_type_length;
225
226 cachefiles_io_error_obj(object,
227 "Can't read xattr on %lu (err %d)",
228 d_backing_inode(dentry)->i_ino, -ret);
229 goto error;
230 }
231
232 /* check the on-disk object */
233 if (ret < 1)
234 goto bad_type_length;
235
236 if (auxbuf->type != auxdata->type)
237 goto stale;
238
239 auxbuf->len = ret;
240
241 /* consult the netfs */
242 if (object->fscache.cookie->def->check_aux) {
243 enum fscache_checkaux result;
244 unsigned int dlen;
245
246 dlen = auxbuf->len - 1;
247
248 _debug("checkaux %s #%u",
249 object->fscache.cookie->def->name, dlen);
250
251 result = fscache_check_aux(&object->fscache,
252 &auxbuf->data, dlen,
253 i_size_read(d_backing_inode(dentry)));
254
255 switch (result) {
256 /* entry okay as is */
257 case FSCACHE_CHECKAUX_OKAY:
258 goto okay;
259
260 /* entry requires update */
261 case FSCACHE_CHECKAUX_NEEDS_UPDATE:
262 break;
263
264 /* entry requires deletion */
265 case FSCACHE_CHECKAUX_OBSOLETE:
266 goto stale;
267
268 default:
269 BUG();
270 }
271
272 /* update the current label */
273 ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
274 &auxdata->type, auxdata->len,
275 XATTR_REPLACE);
276 if (ret < 0) {
277 cachefiles_io_error_obj(object,
278 "Can't update xattr on %lu"
279 " (error %d)",
280 d_backing_inode(dentry)->i_ino, -ret);
281 goto error;
282 }
283 }
284
285okay:
286 ret = 0;
287
288error:
289 kfree(auxbuf);
290 _leave(" = %d", ret);
291 return ret;
292
293bad_type_length:
294 pr_err("Cache object %lu xattr length incorrect\n",
295 d_backing_inode(dentry)->i_ino);
296 ret = -EIO;
297 goto error;
298
299stale:
300 ret = -ESTALE;
301 goto error;
302}
303
304/*
305 * remove the object's xattr to mark it stale
306 */
307int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
308 struct dentry *dentry)
309{
310 int ret;
311
312 ret = vfs_removexattr(dentry, cachefiles_xattr_cache);
313 if (ret < 0) {
314 if (ret == -ENOENT || ret == -ENODATA)
315 ret = 0;
316 else if (ret != -ENOMEM)
317 cachefiles_io_error(cache,
318 "Can't remove xattr from %lu"
319 " (error %d)",
320 d_backing_inode(dentry)->i_ino, -ret);
321 }
322
323 _leave(" = %d", ret);
324 return ret;
325}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* CacheFiles extended attribute management
3 *
4 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/module.h>
9#include <linux/sched.h>
10#include <linux/file.h>
11#include <linux/fs.h>
12#include <linux/fsnotify.h>
13#include <linux/quotaops.h>
14#include <linux/xattr.h>
15#include <linux/slab.h>
16#include "internal.h"
17
18#define CACHEFILES_COOKIE_TYPE_DATA 1
19
20struct cachefiles_xattr {
21 __be64 object_size; /* Actual size of the object */
22 __be64 zero_point; /* Size after which server has no data not written by us */
23 __u8 type; /* Type of object */
24 __u8 content; /* Content presence (enum cachefiles_content) */
25 __u8 data[]; /* netfs coherency data */
26} __packed;
27
28static const char cachefiles_xattr_cache[] =
29 XATTR_USER_PREFIX "CacheFiles.cache";
30
31struct cachefiles_vol_xattr {
32 __be32 reserved; /* Reserved, should be 0 */
33 __u8 data[]; /* netfs volume coherency data */
34} __packed;
35
36/*
37 * set the state xattr on a cache file
38 */
39int cachefiles_set_object_xattr(struct cachefiles_object *object)
40{
41 struct cachefiles_xattr *buf;
42 struct dentry *dentry;
43 struct file *file = object->file;
44 unsigned int len = object->cookie->aux_len;
45 int ret;
46
47 if (!file)
48 return -ESTALE;
49 dentry = file->f_path.dentry;
50
51 _enter("%x,#%d", object->debug_id, len);
52
53 buf = kmalloc(sizeof(struct cachefiles_xattr) + len, GFP_KERNEL);
54 if (!buf)
55 return -ENOMEM;
56
57 buf->object_size = cpu_to_be64(object->cookie->object_size);
58 buf->zero_point = 0;
59 buf->type = CACHEFILES_COOKIE_TYPE_DATA;
60 buf->content = object->content_info;
61 if (test_bit(FSCACHE_COOKIE_LOCAL_WRITE, &object->cookie->flags))
62 buf->content = CACHEFILES_CONTENT_DIRTY;
63 if (len > 0)
64 memcpy(buf->data, fscache_get_aux(object->cookie), len);
65
66 ret = cachefiles_inject_write_error();
67 if (ret == 0) {
68 ret = mnt_want_write_file(file);
69 if (ret == 0) {
70 ret = vfs_setxattr(&nop_mnt_idmap, dentry,
71 cachefiles_xattr_cache, buf,
72 sizeof(struct cachefiles_xattr) + len, 0);
73 mnt_drop_write_file(file);
74 }
75 }
76 if (ret < 0) {
77 trace_cachefiles_vfs_error(object, file_inode(file), ret,
78 cachefiles_trace_setxattr_error);
79 trace_cachefiles_coherency(object, file_inode(file)->i_ino,
80 buf->content,
81 cachefiles_coherency_set_fail);
82 if (ret != -ENOMEM)
83 cachefiles_io_error_obj(
84 object,
85 "Failed to set xattr with error %d", ret);
86 } else {
87 trace_cachefiles_coherency(object, file_inode(file)->i_ino,
88 buf->content,
89 cachefiles_coherency_set_ok);
90 }
91
92 kfree(buf);
93 _leave(" = %d", ret);
94 return ret;
95}
96
97/*
98 * check the consistency between the backing cache and the FS-Cache cookie
99 */
100int cachefiles_check_auxdata(struct cachefiles_object *object, struct file *file)
101{
102 struct cachefiles_xattr *buf;
103 struct dentry *dentry = file->f_path.dentry;
104 unsigned int len = object->cookie->aux_len, tlen;
105 const void *p = fscache_get_aux(object->cookie);
106 enum cachefiles_coherency_trace why;
107 ssize_t xlen;
108 int ret = -ESTALE;
109
110 tlen = sizeof(struct cachefiles_xattr) + len;
111 buf = kmalloc(tlen, GFP_KERNEL);
112 if (!buf)
113 return -ENOMEM;
114
115 xlen = cachefiles_inject_read_error();
116 if (xlen == 0)
117 xlen = vfs_getxattr(&nop_mnt_idmap, dentry, cachefiles_xattr_cache, buf, tlen);
118 if (xlen != tlen) {
119 if (xlen < 0) {
120 ret = xlen;
121 trace_cachefiles_vfs_error(object, file_inode(file), xlen,
122 cachefiles_trace_getxattr_error);
123 }
124 if (xlen == -EIO)
125 cachefiles_io_error_obj(
126 object,
127 "Failed to read aux with error %zd", xlen);
128 why = cachefiles_coherency_check_xattr;
129 } else if (buf->type != CACHEFILES_COOKIE_TYPE_DATA) {
130 why = cachefiles_coherency_check_type;
131 } else if (memcmp(buf->data, p, len) != 0) {
132 why = cachefiles_coherency_check_aux;
133 } else if (be64_to_cpu(buf->object_size) != object->cookie->object_size) {
134 why = cachefiles_coherency_check_objsize;
135 } else if (buf->content == CACHEFILES_CONTENT_DIRTY) {
136 // TODO: Begin conflict resolution
137 pr_warn("Dirty object in cache\n");
138 why = cachefiles_coherency_check_dirty;
139 } else {
140 why = cachefiles_coherency_check_ok;
141 ret = 0;
142 }
143
144 trace_cachefiles_coherency(object, file_inode(file)->i_ino,
145 buf->content, why);
146 kfree(buf);
147 return ret;
148}
149
150/*
151 * remove the object's xattr to mark it stale
152 */
153int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
154 struct cachefiles_object *object,
155 struct dentry *dentry)
156{
157 int ret;
158
159 ret = cachefiles_inject_remove_error();
160 if (ret == 0) {
161 ret = mnt_want_write(cache->mnt);
162 if (ret == 0) {
163 ret = vfs_removexattr(&nop_mnt_idmap, dentry,
164 cachefiles_xattr_cache);
165 mnt_drop_write(cache->mnt);
166 }
167 }
168 if (ret < 0) {
169 trace_cachefiles_vfs_error(object, d_inode(dentry), ret,
170 cachefiles_trace_remxattr_error);
171 if (ret == -ENOENT || ret == -ENODATA)
172 ret = 0;
173 else if (ret != -ENOMEM)
174 cachefiles_io_error(cache,
175 "Can't remove xattr from %lu"
176 " (error %d)",
177 d_backing_inode(dentry)->i_ino, -ret);
178 }
179
180 _leave(" = %d", ret);
181 return ret;
182}
183
184/*
185 * Stick a marker on the cache object to indicate that it's dirty.
186 */
187void cachefiles_prepare_to_write(struct fscache_cookie *cookie)
188{
189 const struct cred *saved_cred;
190 struct cachefiles_object *object = cookie->cache_priv;
191 struct cachefiles_cache *cache = object->volume->cache;
192
193 _enter("c=%08x", object->cookie->debug_id);
194
195 if (!test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags)) {
196 cachefiles_begin_secure(cache, &saved_cred);
197 cachefiles_set_object_xattr(object);
198 cachefiles_end_secure(cache, saved_cred);
199 }
200}
201
202/*
203 * Set the state xattr on a volume directory.
204 */
205bool cachefiles_set_volume_xattr(struct cachefiles_volume *volume)
206{
207 struct cachefiles_vol_xattr *buf;
208 unsigned int len = volume->vcookie->coherency_len;
209 const void *p = volume->vcookie->coherency;
210 struct dentry *dentry = volume->dentry;
211 int ret;
212
213 _enter("%x,#%d", volume->vcookie->debug_id, len);
214
215 len += sizeof(*buf);
216 buf = kmalloc(len, GFP_KERNEL);
217 if (!buf)
218 return false;
219 buf->reserved = cpu_to_be32(0);
220 memcpy(buf->data, p, volume->vcookie->coherency_len);
221
222 ret = cachefiles_inject_write_error();
223 if (ret == 0) {
224 ret = mnt_want_write(volume->cache->mnt);
225 if (ret == 0) {
226 ret = vfs_setxattr(&nop_mnt_idmap, dentry,
227 cachefiles_xattr_cache,
228 buf, len, 0);
229 mnt_drop_write(volume->cache->mnt);
230 }
231 }
232 if (ret < 0) {
233 trace_cachefiles_vfs_error(NULL, d_inode(dentry), ret,
234 cachefiles_trace_setxattr_error);
235 trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,
236 cachefiles_coherency_vol_set_fail);
237 if (ret != -ENOMEM)
238 cachefiles_io_error(
239 volume->cache, "Failed to set xattr with error %d", ret);
240 } else {
241 trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,
242 cachefiles_coherency_vol_set_ok);
243 }
244
245 kfree(buf);
246 _leave(" = %d", ret);
247 return ret == 0;
248}
249
250/*
251 * Check the consistency between the backing cache and the volume cookie.
252 */
253int cachefiles_check_volume_xattr(struct cachefiles_volume *volume)
254{
255 struct cachefiles_vol_xattr *buf;
256 struct dentry *dentry = volume->dentry;
257 unsigned int len = volume->vcookie->coherency_len;
258 const void *p = volume->vcookie->coherency;
259 enum cachefiles_coherency_trace why;
260 ssize_t xlen;
261 int ret = -ESTALE;
262
263 _enter("");
264
265 len += sizeof(*buf);
266 buf = kmalloc(len, GFP_KERNEL);
267 if (!buf)
268 return -ENOMEM;
269
270 xlen = cachefiles_inject_read_error();
271 if (xlen == 0)
272 xlen = vfs_getxattr(&nop_mnt_idmap, dentry, cachefiles_xattr_cache, buf, len);
273 if (xlen != len) {
274 if (xlen < 0) {
275 ret = xlen;
276 trace_cachefiles_vfs_error(NULL, d_inode(dentry), xlen,
277 cachefiles_trace_getxattr_error);
278 if (xlen == -EIO)
279 cachefiles_io_error(
280 volume->cache,
281 "Failed to read xattr with error %zd", xlen);
282 }
283 why = cachefiles_coherency_vol_check_xattr;
284 } else if (buf->reserved != cpu_to_be32(0)) {
285 why = cachefiles_coherency_vol_check_resv;
286 } else if (memcmp(buf->data, p, len - sizeof(*buf)) != 0) {
287 why = cachefiles_coherency_vol_check_cmp;
288 } else {
289 why = cachefiles_coherency_vol_check_ok;
290 ret = 0;
291 }
292
293 trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino, why);
294 kfree(buf);
295 _leave(" = %d", ret);
296 return ret;
297}