xattr.c

  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					   be64_to_cpup((__be64 *)buf->data),
 81					   buf->content,
 82					   cachefiles_coherency_set_fail);
 83		if (ret != -ENOMEM)
 84			cachefiles_io_error_obj(
 85				object,
 86				"Failed to set xattr with error %d", ret);
 87	} else {
 88		trace_cachefiles_coherency(object, file_inode(file)->i_ino,
 89					   be64_to_cpup((__be64 *)buf->data),
 90					   buf->content,
 91					   cachefiles_coherency_set_ok);
 92	}
 93
 94	kfree(buf);
 95	_leave(" = %d", ret);
 96	return ret;
 97}
 98
 99/*
100 * check the consistency between the backing cache and the FS-Cache cookie
101 */
102int cachefiles_check_auxdata(struct cachefiles_object *object, struct file *file)
103{
104	struct cachefiles_xattr *buf;
105	struct dentry *dentry = file->f_path.dentry;
106	unsigned int len = object->cookie->aux_len, tlen;
107	const void *p = fscache_get_aux(object->cookie);
108	enum cachefiles_coherency_trace why;
109	ssize_t xlen;
110	int ret = -ESTALE;
111
112	tlen = sizeof(struct cachefiles_xattr) + len;
113	buf = kmalloc(tlen, GFP_KERNEL);
114	if (!buf)
115		return -ENOMEM;
116
117	xlen = cachefiles_inject_read_error();
118	if (xlen == 0)
119		xlen = vfs_getxattr(&nop_mnt_idmap, dentry, cachefiles_xattr_cache, buf, tlen);
120	if (xlen != tlen) {
121		if (xlen < 0) {
122			ret = xlen;
123			trace_cachefiles_vfs_error(object, file_inode(file), xlen,
124						   cachefiles_trace_getxattr_error);
125		}
126		if (xlen == -EIO)
127			cachefiles_io_error_obj(
128				object,
129				"Failed to read aux with error %zd", xlen);
130		why = cachefiles_coherency_check_xattr;
131		goto out;
132	}
133
134	if (buf->type != CACHEFILES_COOKIE_TYPE_DATA) {
135		why = cachefiles_coherency_check_type;
136	} else if (memcmp(buf->data, p, len) != 0) {
137		why = cachefiles_coherency_check_aux;
138	} else if (be64_to_cpu(buf->object_size) != object->cookie->object_size) {
139		why = cachefiles_coherency_check_objsize;
140	} else if (buf->content == CACHEFILES_CONTENT_DIRTY) {
141		// TODO: Begin conflict resolution
142		pr_warn("Dirty object in cache\n");
143		why = cachefiles_coherency_check_dirty;
144	} else {
145		why = cachefiles_coherency_check_ok;
146		ret = 0;
147	}
148
149out:
150	trace_cachefiles_coherency(object, file_inode(file)->i_ino,
151				   be64_to_cpup((__be64 *)buf->data),
152				   buf->content, why);
153	kfree(buf);
154	return ret;
155}
156
157/*
158 * remove the object's xattr to mark it stale
159 */
160int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
161				   struct cachefiles_object *object,
162				   struct dentry *dentry)
163{
164	int ret;
165
166	ret = cachefiles_inject_remove_error();
167	if (ret == 0) {
168		ret = mnt_want_write(cache->mnt);
169		if (ret == 0) {
170			ret = vfs_removexattr(&nop_mnt_idmap, dentry,
171					      cachefiles_xattr_cache);
172			mnt_drop_write(cache->mnt);
173		}
174	}
175	if (ret < 0) {
176		trace_cachefiles_vfs_error(object, d_inode(dentry), ret,
177					   cachefiles_trace_remxattr_error);
178		if (ret == -ENOENT || ret == -ENODATA)
179			ret = 0;
180		else if (ret != -ENOMEM)
181			cachefiles_io_error(cache,
182					    "Can't remove xattr from %lu"
183					    " (error %d)",
184					    d_backing_inode(dentry)->i_ino, -ret);
185	}
186
187	_leave(" = %d", ret);
188	return ret;
189}
190
191/*
192 * Stick a marker on the cache object to indicate that it's dirty.
193 */
194void cachefiles_prepare_to_write(struct fscache_cookie *cookie)
195{
196	const struct cred *saved_cred;
197	struct cachefiles_object *object = cookie->cache_priv;
198	struct cachefiles_cache *cache = object->volume->cache;
199
200	_enter("c=%08x", object->cookie->debug_id);
201
202	if (!test_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags)) {
203		cachefiles_begin_secure(cache, &saved_cred);
204		cachefiles_set_object_xattr(object);
205		cachefiles_end_secure(cache, saved_cred);
206	}
207}
208
209/*
210 * Set the state xattr on a volume directory.
211 */
212bool cachefiles_set_volume_xattr(struct cachefiles_volume *volume)
213{
214	struct cachefiles_vol_xattr *buf;
215	unsigned int len = volume->vcookie->coherency_len;
216	const void *p = volume->vcookie->coherency;
217	struct dentry *dentry = volume->dentry;
218	int ret;
219
220	_enter("%x,#%d", volume->vcookie->debug_id, len);
221
222	len += sizeof(*buf);
223	buf = kmalloc(len, GFP_KERNEL);
224	if (!buf)
225		return false;
226	buf->reserved = cpu_to_be32(0);
227	memcpy(buf->data, p, volume->vcookie->coherency_len);
228
229	ret = cachefiles_inject_write_error();
230	if (ret == 0) {
231		ret = mnt_want_write(volume->cache->mnt);
232		if (ret == 0) {
233			ret = vfs_setxattr(&nop_mnt_idmap, dentry,
234					   cachefiles_xattr_cache,
235					   buf, len, 0);
236			mnt_drop_write(volume->cache->mnt);
237		}
238	}
239	if (ret < 0) {
240		trace_cachefiles_vfs_error(NULL, d_inode(dentry), ret,
241					   cachefiles_trace_setxattr_error);
242		trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,
243					       cachefiles_coherency_vol_set_fail);
244		if (ret != -ENOMEM)
245			cachefiles_io_error(
246				volume->cache, "Failed to set xattr with error %d", ret);
247	} else {
248		trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,
249					       cachefiles_coherency_vol_set_ok);
250	}
251
252	kfree(buf);
253	_leave(" = %d", ret);
254	return ret == 0;
255}
256
257/*
258 * Check the consistency between the backing cache and the volume cookie.
259 */
260int cachefiles_check_volume_xattr(struct cachefiles_volume *volume)
261{
262	struct cachefiles_vol_xattr *buf;
263	struct dentry *dentry = volume->dentry;
264	unsigned int len = volume->vcookie->coherency_len;
265	const void *p = volume->vcookie->coherency;
266	enum cachefiles_coherency_trace why;
267	ssize_t xlen;
268	int ret = -ESTALE;
269
270	_enter("");
271
272	len += sizeof(*buf);
273	buf = kmalloc(len, GFP_KERNEL);
274	if (!buf)
275		return -ENOMEM;
276
277	xlen = cachefiles_inject_read_error();
278	if (xlen == 0)
279		xlen = vfs_getxattr(&nop_mnt_idmap, dentry, cachefiles_xattr_cache, buf, len);
280	if (xlen != len) {
281		if (xlen < 0) {
282			ret = xlen;
283			trace_cachefiles_vfs_error(NULL, d_inode(dentry), xlen,
284						   cachefiles_trace_getxattr_error);
285			if (xlen == -EIO)
286				cachefiles_io_error(
287					volume->cache,
288					"Failed to read xattr with error %zd", xlen);
289		}
290		why = cachefiles_coherency_vol_check_xattr;
291	} else if (buf->reserved != cpu_to_be32(0)) {
292		why = cachefiles_coherency_vol_check_resv;
293	} else if (memcmp(buf->data, p, len - sizeof(*buf)) != 0) {
294		why = cachefiles_coherency_vol_check_cmp;
295	} else {
296		why = cachefiles_coherency_vol_check_ok;
297		ret = 0;
298	}
299
300	trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino, why);
301	kfree(buf);
302	_leave(" = %d", ret);
303	return ret;
304}