~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cachefiles/xattr.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* CacheFiles extended attribute management
  2  *
  3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
  4  * Written by David Howells (dhowells@redhat.com)
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public Licence
  8  * as published by the Free Software Foundation; either version
  9  * 2 of the Licence, or (at your option) any later version.
 10  */
 11 
 12 #include <linux/module.h>
 13 #include <linux/sched.h>
 14 #include <linux/file.h>
 15 #include <linux/fs.h>
 16 #include <linux/fsnotify.h>
 17 #include <linux/quotaops.h>
 18 #include <linux/xattr.h>
 19 #include <linux/slab.h>
 20 #include "internal.h"
 21 
 22 static const char cachefiles_xattr_cache[] =
 23         XATTR_USER_PREFIX "CacheFiles.cache";
 24 
 25 /*
 26  * check the type label on an object
 27  * - done using xattrs
 28  */
 29 int cachefiles_check_object_type(struct cachefiles_object *object)
 30 {
 31         struct dentry *dentry = object->dentry;
 32         char type[3], xtype[3];
 33         int ret;
 34 
 35         ASSERT(dentry);
 36         ASSERT(d_backing_inode(dentry));
 37 
 38         if (!object->fscache.cookie)
 39                 strcpy(type, "C3");
 40         else
 41                 snprintf(type, 3, "%02x", object->fscache.cookie->def->type);
 42 
 43         _enter("%p{%s}", object, type);
 44 
 45         /* attempt to install a type label directly */
 46         ret = vfs_setxattr(dentry, cachefiles_xattr_cache, type, 2,
 47                            XATTR_CREATE);
 48         if (ret == 0) {
 49                 _debug("SET"); /* we succeeded */
 50                 goto error;
 51         }
 52 
 53         if (ret != -EEXIST) {
 54                 pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
 55                        dentry, d_backing_inode(dentry)->i_ino,
 56                        -ret);
 57                 goto error;
 58         }
 59 
 60         /* read the current type label */
 61         ret = vfs_getxattr(dentry, cachefiles_xattr_cache, xtype, 3);
 62         if (ret < 0) {
 63                 if (ret == -ERANGE)
 64                         goto bad_type_length;
 65 
 66                 pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
 67                        dentry, d_backing_inode(dentry)->i_ino,
 68                        -ret);
 69                 goto error;
 70         }
 71 
 72         /* check the type is what we're expecting */
 73         if (ret != 2)
 74                 goto bad_type_length;
 75 
 76         if (xtype[0] != type[0] || xtype[1] != type[1])
 77                 goto bad_type;
 78 
 79         ret = 0;
 80 
 81 error:
 82         _leave(" = %d", ret);
 83         return ret;
 84 
 85 bad_type_length:
 86         pr_err("Cache object %lu type xattr length incorrect\n",
 87                d_backing_inode(dentry)->i_ino);
 88         ret = -EIO;
 89         goto error;
 90 
 91 bad_type:
 92         xtype[2] = 0;
 93         pr_err("Cache object %pd [%lu] type %s not %s\n",
 94                dentry, d_backing_inode(dentry)->i_ino,
 95                xtype, type);
 96         ret = -EIO;
 97         goto error;
 98 }
 99 
100 /*
101  * set the state xattr on a cache file
102  */
103 int cachefiles_set_object_xattr(struct cachefiles_object *object,
104                                 struct cachefiles_xattr *auxdata)
105 {
106         struct dentry *dentry = object->dentry;
107         int ret;
108 
109         ASSERT(dentry);
110 
111         _enter("%p,#%d", object, auxdata->len);
112 
113         /* attempt to install the cache metadata directly */
114         _debug("SET #%u", auxdata->len);
115 
116         clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
117         ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
118                            &auxdata->type, auxdata->len,
119                            XATTR_CREATE);
120         if (ret < 0 && ret != -ENOMEM)
121                 cachefiles_io_error_obj(
122                         object,
123                         "Failed to set xattr with error %d", ret);
124 
125         _leave(" = %d", ret);
126         return ret;
127 }
128 
129 /*
130  * update the state xattr on a cache file
131  */
132 int cachefiles_update_object_xattr(struct cachefiles_object *object,
133                                    struct cachefiles_xattr *auxdata)
134 {
135         struct dentry *dentry = object->dentry;
136         int ret;
137 
138         if (!dentry)
139                 return -ESTALE;
140 
141         _enter("%p,#%d", object, auxdata->len);
142 
143         /* attempt to install the cache metadata directly */
144         _debug("SET #%u", auxdata->len);
145 
146         clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
147         ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
148                            &auxdata->type, auxdata->len,
149                            XATTR_REPLACE);
150         if (ret < 0 && ret != -ENOMEM)
151                 cachefiles_io_error_obj(
152                         object,
153                         "Failed to update xattr with error %d", ret);
154 
155         _leave(" = %d", ret);
156         return ret;
157 }
158 
159 /*
160  * check the consistency between the backing cache and the FS-Cache cookie
161  */
162 int cachefiles_check_auxdata(struct cachefiles_object *object)
163 {
164         struct cachefiles_xattr *auxbuf;
165         enum fscache_checkaux validity;
166         struct dentry *dentry = object->dentry;
167         ssize_t xlen;
168         int ret;
169 
170         ASSERT(dentry);
171         ASSERT(d_backing_inode(dentry));
172         ASSERT(object->fscache.cookie->def->check_aux);
173 
174         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
175         if (!auxbuf)
176                 return -ENOMEM;
177 
178         xlen = vfs_getxattr(dentry, cachefiles_xattr_cache,
179                             &auxbuf->type, 512 + 1);
180         ret = -ESTALE;
181         if (xlen < 1 ||
182             auxbuf->type != object->fscache.cookie->def->type)
183                 goto error;
184 
185         xlen--;
186         validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen,
187                                      i_size_read(d_backing_inode(dentry)));
188         if (validity != FSCACHE_CHECKAUX_OKAY)
189                 goto error;
190 
191         ret = 0;
192 error:
193         kfree(auxbuf);
194         return ret;
195 }
196 
197 /*
198  * check the state xattr on a cache file
199  * - return -ESTALE if the object should be deleted
200  */
201 int cachefiles_check_object_xattr(struct cachefiles_object *object,
202                                   struct cachefiles_xattr *auxdata)
203 {
204         struct cachefiles_xattr *auxbuf;
205         struct dentry *dentry = object->dentry;
206         int ret;
207 
208         _enter("%p,#%d", object, auxdata->len);
209 
210         ASSERT(dentry);
211         ASSERT(d_backing_inode(dentry));
212 
213         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
214         if (!auxbuf) {
215                 _leave(" = -ENOMEM");
216                 return -ENOMEM;
217         }
218 
219         /* read the current type label */
220         ret = vfs_getxattr(dentry, cachefiles_xattr_cache,
221                            &auxbuf->type, 512 + 1);
222         if (ret < 0) {
223                 if (ret == -ENODATA)
224                         goto stale; /* no attribute - power went off
225                                      * mid-cull? */
226 
227                 if (ret == -ERANGE)
228                         goto bad_type_length;
229 
230                 cachefiles_io_error_obj(object,
231                                         "Can't read xattr on %lu (err %d)",
232                                         d_backing_inode(dentry)->i_ino, -ret);
233                 goto error;
234         }
235 
236         /* check the on-disk object */
237         if (ret < 1)
238                 goto bad_type_length;
239 
240         if (auxbuf->type != auxdata->type)
241                 goto stale;
242 
243         auxbuf->len = ret;
244 
245         /* consult the netfs */
246         if (object->fscache.cookie->def->check_aux) {
247                 enum fscache_checkaux result;
248                 unsigned int dlen;
249 
250                 dlen = auxbuf->len - 1;
251 
252                 _debug("checkaux %s #%u",
253                        object->fscache.cookie->def->name, dlen);
254 
255                 result = fscache_check_aux(&object->fscache,
256                                            &auxbuf->data, dlen,
257                                            i_size_read(d_backing_inode(dentry)));
258 
259                 switch (result) {
260                         /* entry okay as is */
261                 case FSCACHE_CHECKAUX_OKAY:
262                         goto okay;
263 
264                         /* entry requires update */
265                 case FSCACHE_CHECKAUX_NEEDS_UPDATE:
266                         break;
267 
268                         /* entry requires deletion */
269                 case FSCACHE_CHECKAUX_OBSOLETE:
270                         goto stale;
271 
272                 default:
273                         BUG();
274                 }
275 
276                 /* update the current label */
277                 ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
278                                    &auxdata->type, auxdata->len,
279                                    XATTR_REPLACE);
280                 if (ret < 0) {
281                         cachefiles_io_error_obj(object,
282                                                 "Can't update xattr on %lu"
283                                                 " (error %d)",
284                                                 d_backing_inode(dentry)->i_ino, -ret);
285                         goto error;
286                 }
287         }
288 
289 okay:
290         ret = 0;
291 
292 error:
293         kfree(auxbuf);
294         _leave(" = %d", ret);
295         return ret;
296 
297 bad_type_length:
298         pr_err("Cache object %lu xattr length incorrect\n",
299                d_backing_inode(dentry)->i_ino);
300         ret = -EIO;
301         goto error;
302 
303 stale:
304         ret = -ESTALE;
305         goto error;
306 }
307 
308 /*
309  * remove the object's xattr to mark it stale
310  */
311 int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
312                                    struct dentry *dentry)
313 {
314         int ret;
315 
316         ret = vfs_removexattr(dentry, cachefiles_xattr_cache);
317         if (ret < 0) {
318                 if (ret == -ENOENT || ret == -ENODATA)
319                         ret = 0;
320                 else if (ret != -ENOMEM)
321                         cachefiles_io_error(cache,
322                                             "Can't remove xattr from %lu"
323                                             " (error %d)",
324                                             d_backing_inode(dentry)->i_ino, -ret);
325         }
326 
327         _leave(" = %d", ret);
328         return ret;
329 }
330 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp