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

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

Version: ~ [ linux-5.1-rc2 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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 /*
  2  *   Copyright (C) International Business Machines  Corp., 2000-2004
  3  *   Copyright (C) Christoph Hellwig, 2002
  4  *
  5  *   This program is free software;  you can redistribute it and/or modify
  6  *   it under the terms of the GNU General Public License as published by
  7  *   the Free Software Foundation; either version 2 of the License, or
  8  *   (at your option) any later version.
  9  *
 10  *   This program is distributed in the hope that it will be useful,
 11  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 13  *   the GNU General Public License for more details.
 14  *
 15  *   You should have received a copy of the GNU General Public License
 16  *   along with this program;  if not, write to the Free Software
 17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 18  */
 19 
 20 #include <linux/capability.h>
 21 #include <linux/fs.h>
 22 #include <linux/xattr.h>
 23 #include <linux/posix_acl_xattr.h>
 24 #include <linux/slab.h>
 25 #include <linux/quotaops.h>
 26 #include <linux/security.h>
 27 #include "jfs_incore.h"
 28 #include "jfs_superblock.h"
 29 #include "jfs_dmap.h"
 30 #include "jfs_debug.h"
 31 #include "jfs_dinode.h"
 32 #include "jfs_extent.h"
 33 #include "jfs_metapage.h"
 34 #include "jfs_xattr.h"
 35 #include "jfs_acl.h"
 36 
 37 /*
 38  *      jfs_xattr.c: extended attribute service
 39  *
 40  * Overall design --
 41  *
 42  * Format:
 43  *
 44  *   Extended attribute lists (jfs_ea_list) consist of an overall size (32 bit
 45  *   value) and a variable (0 or more) number of extended attribute
 46  *   entries.  Each extended attribute entry (jfs_ea) is a <name,value> double
 47  *   where <name> is constructed from a null-terminated ascii string
 48  *   (1 ... 255 bytes in the name) and <value> is arbitrary 8 bit data
 49  *   (1 ... 65535 bytes).  The in-memory format is
 50  *
 51  *   0       1        2        4                4 + namelen + 1
 52  *   +-------+--------+--------+----------------+-------------------+
 53  *   | Flags | Name   | Value  | Name String \0 | Data . . . .      |
 54  *   |       | Length | Length |                |                   |
 55  *   +-------+--------+--------+----------------+-------------------+
 56  *
 57  *   A jfs_ea_list then is structured as
 58  *
 59  *   0            4                   4 + EA_SIZE(ea1)
 60  *   +------------+-------------------+--------------------+-----
 61  *   | Overall EA | First FEA Element | Second FEA Element | .....
 62  *   | List Size  |                   |                    |
 63  *   +------------+-------------------+--------------------+-----
 64  *
 65  *   On-disk:
 66  *
 67  *      FEALISTs are stored on disk using blocks allocated by dbAlloc() and
 68  *      written directly. An EA list may be in-lined in the inode if there is
 69  *      sufficient room available.
 70  */
 71 
 72 struct ea_buffer {
 73         int flag;               /* Indicates what storage xattr points to */
 74         int max_size;           /* largest xattr that fits in current buffer */
 75         dxd_t new_ea;           /* dxd to replace ea when modifying xattr */
 76         struct metapage *mp;    /* metapage containing ea list */
 77         struct jfs_ea_list *xattr;      /* buffer containing ea list */
 78 };
 79 
 80 /*
 81  * ea_buffer.flag values
 82  */
 83 #define EA_INLINE       0x0001
 84 #define EA_EXTENT       0x0002
 85 #define EA_NEW          0x0004
 86 #define EA_MALLOC       0x0008
 87 
 88 
 89 /*
 90  * Mapping of on-disk attribute names: for on-disk attribute names with an
 91  * unknown prefix (not "system.", "user.", "security.", or "trusted."), the
 92  * prefix "os2." is prepended.  On the way back to disk, "os2." prefixes are
 93  * stripped and we make sure that the remaining name does not start with one
 94  * of the know prefixes.
 95  */
 96 
 97 static int is_known_namespace(const char *name)
 98 {
 99         if (strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) &&
100             strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
101             strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
102             strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
103                 return false;
104 
105         return true;
106 }
107 
108 static inline int name_size(struct jfs_ea *ea)
109 {
110         if (is_known_namespace(ea->name))
111                 return ea->namelen;
112         else
113                 return ea->namelen + XATTR_OS2_PREFIX_LEN;
114 }
115 
116 static inline int copy_name(char *buffer, struct jfs_ea *ea)
117 {
118         int len = ea->namelen;
119 
120         if (!is_known_namespace(ea->name)) {
121                 memcpy(buffer, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN);
122                 buffer += XATTR_OS2_PREFIX_LEN;
123                 len += XATTR_OS2_PREFIX_LEN;
124         }
125         memcpy(buffer, ea->name, ea->namelen);
126         buffer[ea->namelen] = 0;
127 
128         return len;
129 }
130 
131 /* Forward references */
132 static void ea_release(struct inode *inode, struct ea_buffer *ea_buf);
133 
134 /*
135  * NAME: ea_write_inline
136  *
137  * FUNCTION: Attempt to write an EA inline if area is available
138  *
139  * PRE CONDITIONS:
140  *      Already verified that the specified EA is small enough to fit inline
141  *
142  * PARAMETERS:
143  *      ip      - Inode pointer
144  *      ealist  - EA list pointer
145  *      size    - size of ealist in bytes
146  *      ea      - dxd_t structure to be filled in with necessary EA information
147  *                if we successfully copy the EA inline
148  *
149  * NOTES:
150  *      Checks if the inode's inline area is available.  If so, copies EA inline
151  *      and sets <ea> fields appropriately.  Otherwise, returns failure, EA will
152  *      have to be put into an extent.
153  *
154  * RETURNS: 0 for successful copy to inline area; -1 if area not available
155  */
156 static int ea_write_inline(struct inode *ip, struct jfs_ea_list *ealist,
157                            int size, dxd_t * ea)
158 {
159         struct jfs_inode_info *ji = JFS_IP(ip);
160 
161         /*
162          * Make sure we have an EA -- the NULL EA list is valid, but you
163          * can't copy it!
164          */
165         if (ealist && size > sizeof (struct jfs_ea_list)) {
166                 assert(size <= sizeof (ji->i_inline_ea));
167 
168                 /*
169                  * See if the space is available or if it is already being
170                  * used for an inline EA.
171                  */
172                 if (!(ji->mode2 & INLINEEA) && !(ji->ea.flag & DXD_INLINE))
173                         return -EPERM;
174 
175                 DXDsize(ea, size);
176                 DXDlength(ea, 0);
177                 DXDaddress(ea, 0);
178                 memcpy(ji->i_inline_ea, ealist, size);
179                 ea->flag = DXD_INLINE;
180                 ji->mode2 &= ~INLINEEA;
181         } else {
182                 ea->flag = 0;
183                 DXDsize(ea, 0);
184                 DXDlength(ea, 0);
185                 DXDaddress(ea, 0);
186 
187                 /* Free up INLINE area */
188                 if (ji->ea.flag & DXD_INLINE)
189                         ji->mode2 |= INLINEEA;
190         }
191 
192         return 0;
193 }
194 
195 /*
196  * NAME: ea_write
197  *
198  * FUNCTION: Write an EA for an inode
199  *
200  * PRE CONDITIONS: EA has been verified
201  *
202  * PARAMETERS:
203  *      ip      - Inode pointer
204  *      ealist  - EA list pointer
205  *      size    - size of ealist in bytes
206  *      ea      - dxd_t structure to be filled in appropriately with where the
207  *                EA was copied
208  *
209  * NOTES: Will write EA inline if able to, otherwise allocates blocks for an
210  *      extent and synchronously writes it to those blocks.
211  *
212  * RETURNS: 0 for success; Anything else indicates failure
213  */
214 static int ea_write(struct inode *ip, struct jfs_ea_list *ealist, int size,
215                        dxd_t * ea)
216 {
217         struct super_block *sb = ip->i_sb;
218         struct jfs_inode_info *ji = JFS_IP(ip);
219         struct jfs_sb_info *sbi = JFS_SBI(sb);
220         int nblocks;
221         s64 blkno;
222         int rc = 0, i;
223         char *cp;
224         s32 nbytes, nb;
225         s32 bytes_to_write;
226         struct metapage *mp;
227 
228         /*
229          * Quick check to see if this is an in-linable EA.  Short EAs
230          * and empty EAs are all in-linable, provided the space exists.
231          */
232         if (!ealist || size <= sizeof (ji->i_inline_ea)) {
233                 if (!ea_write_inline(ip, ealist, size, ea))
234                         return 0;
235         }
236 
237         /* figure out how many blocks we need */
238         nblocks = (size + (sb->s_blocksize - 1)) >> sb->s_blocksize_bits;
239 
240         /* Allocate new blocks to quota. */
241         rc = dquot_alloc_block(ip, nblocks);
242         if (rc)
243                 return rc;
244 
245         rc = dbAlloc(ip, INOHINT(ip), nblocks, &blkno);
246         if (rc) {
247                 /*Rollback quota allocation. */
248                 dquot_free_block(ip, nblocks);
249                 return rc;
250         }
251 
252         /*
253          * Now have nblocks worth of storage to stuff into the FEALIST.
254          * loop over the FEALIST copying data into the buffer one page at
255          * a time.
256          */
257         cp = (char *) ealist;
258         nbytes = size;
259         for (i = 0; i < nblocks; i += sbi->nbperpage) {
260                 /*
261                  * Determine how many bytes for this request, and round up to
262                  * the nearest aggregate block size
263                  */
264                 nb = min(PSIZE, nbytes);
265                 bytes_to_write =
266                     ((((nb + sb->s_blocksize - 1)) >> sb->s_blocksize_bits))
267                     << sb->s_blocksize_bits;
268 
269                 if (!(mp = get_metapage(ip, blkno + i, bytes_to_write, 1))) {
270                         rc = -EIO;
271                         goto failed;
272                 }
273 
274                 memcpy(mp->data, cp, nb);
275 
276                 /*
277                  * We really need a way to propagate errors for
278                  * forced writes like this one.  --hch
279                  *
280                  * (__write_metapage => release_metapage => flush_metapage)
281                  */
282 #ifdef _JFS_FIXME
283                 if ((rc = flush_metapage(mp))) {
284                         /*
285                          * the write failed -- this means that the buffer
286                          * is still assigned and the blocks are not being
287                          * used.  this seems like the best error recovery
288                          * we can get ...
289                          */
290                         goto failed;
291                 }
292 #else
293                 flush_metapage(mp);
294 #endif
295 
296                 cp += PSIZE;
297                 nbytes -= nb;
298         }
299 
300         ea->flag = DXD_EXTENT;
301         DXDsize(ea, le32_to_cpu(ealist->size));
302         DXDlength(ea, nblocks);
303         DXDaddress(ea, blkno);
304 
305         /* Free up INLINE area */
306         if (ji->ea.flag & DXD_INLINE)
307                 ji->mode2 |= INLINEEA;
308 
309         return 0;
310 
311       failed:
312         /* Rollback quota allocation. */
313         dquot_free_block(ip, nblocks);
314 
315         dbFree(ip, blkno, nblocks);
316         return rc;
317 }
318 
319 /*
320  * NAME: ea_read_inline
321  *
322  * FUNCTION: Read an inlined EA into user's buffer
323  *
324  * PARAMETERS:
325  *      ip      - Inode pointer
326  *      ealist  - Pointer to buffer to fill in with EA
327  *
328  * RETURNS: 0
329  */
330 static int ea_read_inline(struct inode *ip, struct jfs_ea_list *ealist)
331 {
332         struct jfs_inode_info *ji = JFS_IP(ip);
333         int ea_size = sizeDXD(&ji->ea);
334 
335         if (ea_size == 0) {
336                 ealist->size = 0;
337                 return 0;
338         }
339 
340         /* Sanity Check */
341         if ((sizeDXD(&ji->ea) > sizeof (ji->i_inline_ea)))
342                 return -EIO;
343         if (le32_to_cpu(((struct jfs_ea_list *) &ji->i_inline_ea)->size)
344             != ea_size)
345                 return -EIO;
346 
347         memcpy(ealist, ji->i_inline_ea, ea_size);
348         return 0;
349 }
350 
351 /*
352  * NAME: ea_read
353  *
354  * FUNCTION: copy EA data into user's buffer
355  *
356  * PARAMETERS:
357  *      ip      - Inode pointer
358  *      ealist  - Pointer to buffer to fill in with EA
359  *
360  * NOTES:  If EA is inline calls ea_read_inline() to copy EA.
361  *
362  * RETURNS: 0 for success; other indicates failure
363  */
364 static int ea_read(struct inode *ip, struct jfs_ea_list *ealist)
365 {
366         struct super_block *sb = ip->i_sb;
367         struct jfs_inode_info *ji = JFS_IP(ip);
368         struct jfs_sb_info *sbi = JFS_SBI(sb);
369         int nblocks;
370         s64 blkno;
371         char *cp = (char *) ealist;
372         int i;
373         int nbytes, nb;
374         s32 bytes_to_read;
375         struct metapage *mp;
376 
377         /* quick check for in-line EA */
378         if (ji->ea.flag & DXD_INLINE)
379                 return ea_read_inline(ip, ealist);
380 
381         nbytes = sizeDXD(&ji->ea);
382         if (!nbytes) {
383                 jfs_error(sb, "nbytes is 0\n");
384                 return -EIO;
385         }
386 
387         /*
388          * Figure out how many blocks were allocated when this EA list was
389          * originally written to disk.
390          */
391         nblocks = lengthDXD(&ji->ea) << sbi->l2nbperpage;
392         blkno = addressDXD(&ji->ea) << sbi->l2nbperpage;
393 
394         /*
395          * I have found the disk blocks which were originally used to store
396          * the FEALIST.  now i loop over each contiguous block copying the
397          * data into the buffer.
398          */
399         for (i = 0; i < nblocks; i += sbi->nbperpage) {
400                 /*
401                  * Determine how many bytes for this request, and round up to
402                  * the nearest aggregate block size
403                  */
404                 nb = min(PSIZE, nbytes);
405                 bytes_to_read =
406                     ((((nb + sb->s_blocksize - 1)) >> sb->s_blocksize_bits))
407                     << sb->s_blocksize_bits;
408 
409                 if (!(mp = read_metapage(ip, blkno + i, bytes_to_read, 1)))
410                         return -EIO;
411 
412                 memcpy(cp, mp->data, nb);
413                 release_metapage(mp);
414 
415                 cp += PSIZE;
416                 nbytes -= nb;
417         }
418 
419         return 0;
420 }
421 
422 /*
423  * NAME: ea_get
424  *
425  * FUNCTION: Returns buffer containing existing extended attributes.
426  *           The size of the buffer will be the larger of the existing
427  *           attributes size, or min_size.
428  *
429  *           The buffer, which may be inlined in the inode or in the
430  *           page cache must be release by calling ea_release or ea_put
431  *
432  * PARAMETERS:
433  *      inode   - Inode pointer
434  *      ea_buf  - Structure to be populated with ealist and its metadata
435  *      min_size- minimum size of buffer to be returned
436  *
437  * RETURNS: 0 for success; Other indicates failure
438  */
439 static int ea_get(struct inode *inode, struct ea_buffer *ea_buf, int min_size)
440 {
441         struct jfs_inode_info *ji = JFS_IP(inode);
442         struct super_block *sb = inode->i_sb;
443         int size;
444         int ea_size = sizeDXD(&ji->ea);
445         int blocks_needed, current_blocks;
446         s64 blkno;
447         int rc;
448         int quota_allocation = 0;
449 
450         /* When fsck.jfs clears a bad ea, it doesn't clear the size */
451         if (ji->ea.flag == 0)
452                 ea_size = 0;
453 
454         if (ea_size == 0) {
455                 if (min_size == 0) {
456                         ea_buf->flag = 0;
457                         ea_buf->max_size = 0;
458                         ea_buf->xattr = NULL;
459                         return 0;
460                 }
461                 if ((min_size <= sizeof (ji->i_inline_ea)) &&
462                     (ji->mode2 & INLINEEA)) {
463                         ea_buf->flag = EA_INLINE | EA_NEW;
464                         ea_buf->max_size = sizeof (ji->i_inline_ea);
465                         ea_buf->xattr = (struct jfs_ea_list *) ji->i_inline_ea;
466                         DXDlength(&ea_buf->new_ea, 0);
467                         DXDaddress(&ea_buf->new_ea, 0);
468                         ea_buf->new_ea.flag = DXD_INLINE;
469                         DXDsize(&ea_buf->new_ea, min_size);
470                         return 0;
471                 }
472                 current_blocks = 0;
473         } else if (ji->ea.flag & DXD_INLINE) {
474                 if (min_size <= sizeof (ji->i_inline_ea)) {
475                         ea_buf->flag = EA_INLINE;
476                         ea_buf->max_size = sizeof (ji->i_inline_ea);
477                         ea_buf->xattr = (struct jfs_ea_list *) ji->i_inline_ea;
478                         goto size_check;
479                 }
480                 current_blocks = 0;
481         } else {
482                 if (!(ji->ea.flag & DXD_EXTENT)) {
483                         jfs_error(sb, "invalid ea.flag\n");
484                         return -EIO;
485                 }
486                 current_blocks = (ea_size + sb->s_blocksize - 1) >>
487                     sb->s_blocksize_bits;
488         }
489         size = max(min_size, ea_size);
490 
491         if (size > PSIZE) {
492                 /*
493                  * To keep the rest of the code simple.  Allocate a
494                  * contiguous buffer to work with
495                  */
496                 ea_buf->xattr = kmalloc(size, GFP_KERNEL);
497                 if (ea_buf->xattr == NULL)
498                         return -ENOMEM;
499 
500                 ea_buf->flag = EA_MALLOC;
501                 ea_buf->max_size = (size + sb->s_blocksize - 1) &
502                     ~(sb->s_blocksize - 1);
503 
504                 if (ea_size == 0)
505                         return 0;
506 
507                 if ((rc = ea_read(inode, ea_buf->xattr))) {
508                         kfree(ea_buf->xattr);
509                         ea_buf->xattr = NULL;
510                         return rc;
511                 }
512                 goto size_check;
513         }
514         blocks_needed = (min_size + sb->s_blocksize - 1) >>
515             sb->s_blocksize_bits;
516 
517         if (blocks_needed > current_blocks) {
518                 /* Allocate new blocks to quota. */
519                 rc = dquot_alloc_block(inode, blocks_needed);
520                 if (rc)
521                         return -EDQUOT;
522 
523                 quota_allocation = blocks_needed;
524 
525                 rc = dbAlloc(inode, INOHINT(inode), (s64) blocks_needed,
526                              &blkno);
527                 if (rc)
528                         goto clean_up;
529 
530                 DXDlength(&ea_buf->new_ea, blocks_needed);
531                 DXDaddress(&ea_buf->new_ea, blkno);
532                 ea_buf->new_ea.flag = DXD_EXTENT;
533                 DXDsize(&ea_buf->new_ea, min_size);
534 
535                 ea_buf->flag = EA_EXTENT | EA_NEW;
536 
537                 ea_buf->mp = get_metapage(inode, blkno,
538                                           blocks_needed << sb->s_blocksize_bits,
539                                           1);
540                 if (ea_buf->mp == NULL) {
541                         dbFree(inode, blkno, (s64) blocks_needed);
542                         rc = -EIO;
543                         goto clean_up;
544                 }
545                 ea_buf->xattr = ea_buf->mp->data;
546                 ea_buf->max_size = (min_size + sb->s_blocksize - 1) &
547                     ~(sb->s_blocksize - 1);
548                 if (ea_size == 0)
549                         return 0;
550                 if ((rc = ea_read(inode, ea_buf->xattr))) {
551                         discard_metapage(ea_buf->mp);
552                         dbFree(inode, blkno, (s64) blocks_needed);
553                         goto clean_up;
554                 }
555                 goto size_check;
556         }
557         ea_buf->flag = EA_EXTENT;
558         ea_buf->mp = read_metapage(inode, addressDXD(&ji->ea),
559                                    lengthDXD(&ji->ea) << sb->s_blocksize_bits,
560                                    1);
561         if (ea_buf->mp == NULL) {
562                 rc = -EIO;
563                 goto clean_up;
564         }
565         ea_buf->xattr = ea_buf->mp->data;
566         ea_buf->max_size = (ea_size + sb->s_blocksize - 1) &
567             ~(sb->s_blocksize - 1);
568 
569       size_check:
570         if (EALIST_SIZE(ea_buf->xattr) != ea_size) {
571                 printk(KERN_ERR "ea_get: invalid extended attribute\n");
572                 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_ADDRESS, 16, 1,
573                                      ea_buf->xattr, ea_size, 1);
574                 ea_release(inode, ea_buf);
575                 rc = -EIO;
576                 goto clean_up;
577         }
578 
579         return ea_size;
580 
581       clean_up:
582         /* Rollback quota allocation */
583         if (quota_allocation)
584                 dquot_free_block(inode, quota_allocation);
585 
586         return (rc);
587 }
588 
589 static void ea_release(struct inode *inode, struct ea_buffer *ea_buf)
590 {
591         if (ea_buf->flag & EA_MALLOC)
592                 kfree(ea_buf->xattr);
593         else if (ea_buf->flag & EA_EXTENT) {
594                 assert(ea_buf->mp);
595                 release_metapage(ea_buf->mp);
596 
597                 if (ea_buf->flag & EA_NEW)
598                         dbFree(inode, addressDXD(&ea_buf->new_ea),
599                                lengthDXD(&ea_buf->new_ea));
600         }
601 }
602 
603 static int ea_put(tid_t tid, struct inode *inode, struct ea_buffer *ea_buf,
604                   int new_size)
605 {
606         struct jfs_inode_info *ji = JFS_IP(inode);
607         unsigned long old_blocks, new_blocks;
608         int rc = 0;
609 
610         if (new_size == 0) {
611                 ea_release(inode, ea_buf);
612                 ea_buf = NULL;
613         } else if (ea_buf->flag & EA_INLINE) {
614                 assert(new_size <= sizeof (ji->i_inline_ea));
615                 ji->mode2 &= ~INLINEEA;
616                 ea_buf->new_ea.flag = DXD_INLINE;
617                 DXDsize(&ea_buf->new_ea, new_size);
618                 DXDaddress(&ea_buf->new_ea, 0);
619                 DXDlength(&ea_buf->new_ea, 0);
620         } else if (ea_buf->flag & EA_MALLOC) {
621                 rc = ea_write(inode, ea_buf->xattr, new_size, &ea_buf->new_ea);
622                 kfree(ea_buf->xattr);
623         } else if (ea_buf->flag & EA_NEW) {
624                 /* We have already allocated a new dxd */
625                 flush_metapage(ea_buf->mp);
626         } else {
627                 /* ->xattr must point to original ea's metapage */
628                 rc = ea_write(inode, ea_buf->xattr, new_size, &ea_buf->new_ea);
629                 discard_metapage(ea_buf->mp);
630         }
631         if (rc)
632                 return rc;
633 
634         old_blocks = new_blocks = 0;
635 
636         if (ji->ea.flag & DXD_EXTENT) {
637                 invalidate_dxd_metapages(inode, ji->ea);
638                 old_blocks = lengthDXD(&ji->ea);
639         }
640 
641         if (ea_buf) {
642                 txEA(tid, inode, &ji->ea, &ea_buf->new_ea);
643                 if (ea_buf->new_ea.flag & DXD_EXTENT) {
644                         new_blocks = lengthDXD(&ea_buf->new_ea);
645                         if (ji->ea.flag & DXD_INLINE)
646                                 ji->mode2 |= INLINEEA;
647                 }
648                 ji->ea = ea_buf->new_ea;
649         } else {
650                 txEA(tid, inode, &ji->ea, NULL);
651                 if (ji->ea.flag & DXD_INLINE)
652                         ji->mode2 |= INLINEEA;
653                 ji->ea.flag = 0;
654                 ji->ea.size = 0;
655         }
656 
657         /* If old blocks exist, they must be removed from quota allocation. */
658         if (old_blocks)
659                 dquot_free_block(inode, old_blocks);
660 
661         inode->i_ctime = current_time(inode);
662 
663         return 0;
664 }
665 
666 int __jfs_setxattr(tid_t tid, struct inode *inode, const char *name,
667                    const void *value, size_t value_len, int flags)
668 {
669         struct jfs_ea_list *ealist;
670         struct jfs_ea *ea, *old_ea = NULL, *next_ea = NULL;
671         struct ea_buffer ea_buf;
672         int old_ea_size = 0;
673         int xattr_size;
674         int new_size;
675         int namelen = strlen(name);
676         int found = 0;
677         int rc;
678         int length;
679 
680         down_write(&JFS_IP(inode)->xattr_sem);
681 
682         xattr_size = ea_get(inode, &ea_buf, 0);
683         if (xattr_size < 0) {
684                 rc = xattr_size;
685                 goto out;
686         }
687 
688       again:
689         ealist = (struct jfs_ea_list *) ea_buf.xattr;
690         new_size = sizeof (struct jfs_ea_list);
691 
692         if (xattr_size) {
693                 for (ea = FIRST_EA(ealist); ea < END_EALIST(ealist);
694                      ea = NEXT_EA(ea)) {
695                         if ((namelen == ea->namelen) &&
696                             (memcmp(name, ea->name, namelen) == 0)) {
697                                 found = 1;
698                                 if (flags & XATTR_CREATE) {
699                                         rc = -EEXIST;
700                                         goto release;
701                                 }
702                                 old_ea = ea;
703                                 old_ea_size = EA_SIZE(ea);
704                                 next_ea = NEXT_EA(ea);
705                         } else
706                                 new_size += EA_SIZE(ea);
707                 }
708         }
709 
710         if (!found) {
711                 if (flags & XATTR_REPLACE) {
712                         rc = -ENODATA;
713                         goto release;
714                 }
715                 if (value == NULL) {
716                         rc = 0;
717                         goto release;
718                 }
719         }
720         if (value)
721                 new_size += sizeof (struct jfs_ea) + namelen + 1 + value_len;
722 
723         if (new_size > ea_buf.max_size) {
724                 /*
725                  * We need to allocate more space for merged ea list.
726                  * We should only have loop to again: once.
727                  */
728                 ea_release(inode, &ea_buf);
729                 xattr_size = ea_get(inode, &ea_buf, new_size);
730                 if (xattr_size < 0) {
731                         rc = xattr_size;
732                         goto out;
733                 }
734                 goto again;
735         }
736 
737         /* Remove old ea of the same name */
738         if (found) {
739                 /* number of bytes following target EA */
740                 length = (char *) END_EALIST(ealist) - (char *) next_ea;
741                 if (length > 0)
742                         memmove(old_ea, next_ea, length);
743                 xattr_size -= old_ea_size;
744         }
745 
746         /* Add new entry to the end */
747         if (value) {
748                 if (xattr_size == 0)
749                         /* Completely new ea list */
750                         xattr_size = sizeof (struct jfs_ea_list);
751 
752                 /*
753                  * The size of EA value is limitted by on-disk format up to
754                  *  __le16, there would be an overflow if the size is equal
755                  * to XATTR_SIZE_MAX (65536).  In order to avoid this issue,
756                  * we can pre-checkup the value size against USHRT_MAX, and
757                  * return -E2BIG in this case, which is consistent with the
758                  * VFS setxattr interface.
759                  */
760                 if (value_len >= USHRT_MAX) {
761                         rc = -E2BIG;
762                         goto release;
763                 }
764 
765                 ea = (struct jfs_ea *) ((char *) ealist + xattr_size);
766                 ea->flag = 0;
767                 ea->namelen = namelen;
768                 ea->valuelen = (cpu_to_le16(value_len));
769                 memcpy(ea->name, name, namelen);
770                 ea->name[namelen] = 0;
771                 if (value_len)
772                         memcpy(&ea->name[namelen + 1], value, value_len);
773                 xattr_size += EA_SIZE(ea);
774         }
775 
776         /* DEBUG - If we did this right, these number match */
777         if (xattr_size != new_size) {
778                 printk(KERN_ERR
779                        "__jfs_setxattr: xattr_size = %d, new_size = %d\n",
780                        xattr_size, new_size);
781 
782                 rc = -EINVAL;
783                 goto release;
784         }
785 
786         /*
787          * If we're left with an empty list, there's no ea
788          */
789         if (new_size == sizeof (struct jfs_ea_list))
790                 new_size = 0;
791 
792         ealist->size = cpu_to_le32(new_size);
793 
794         rc = ea_put(tid, inode, &ea_buf, new_size);
795 
796         goto out;
797       release:
798         ea_release(inode, &ea_buf);
799       out:
800         up_write(&JFS_IP(inode)->xattr_sem);
801 
802         return rc;
803 }
804 
805 ssize_t __jfs_getxattr(struct inode *inode, const char *name, void *data,
806                        size_t buf_size)
807 {
808         struct jfs_ea_list *ealist;
809         struct jfs_ea *ea;
810         struct ea_buffer ea_buf;
811         int xattr_size;
812         ssize_t size;
813         int namelen = strlen(name);
814         char *value;
815 
816         down_read(&JFS_IP(inode)->xattr_sem);
817 
818         xattr_size = ea_get(inode, &ea_buf, 0);
819 
820         if (xattr_size < 0) {
821                 size = xattr_size;
822                 goto out;
823         }
824 
825         if (xattr_size == 0)
826                 goto not_found;
827 
828         ealist = (struct jfs_ea_list *) ea_buf.xattr;
829 
830         /* Find the named attribute */
831         for (ea = FIRST_EA(ealist); ea < END_EALIST(ealist); ea = NEXT_EA(ea))
832                 if ((namelen == ea->namelen) &&
833                     memcmp(name, ea->name, namelen) == 0) {
834                         /* Found it */
835                         size = le16_to_cpu(ea->valuelen);
836                         if (!data)
837                                 goto release;
838                         else if (size > buf_size) {
839                                 size = -ERANGE;
840                                 goto release;
841                         }
842                         value = ((char *) &ea->name) + ea->namelen + 1;
843                         memcpy(data, value, size);
844                         goto release;
845                 }
846       not_found:
847         size = -ENODATA;
848       release:
849         ea_release(inode, &ea_buf);
850       out:
851         up_read(&JFS_IP(inode)->xattr_sem);
852 
853         return size;
854 }
855 
856 /*
857  * No special permissions are needed to list attributes except for trusted.*
858  */
859 static inline int can_list(struct jfs_ea *ea)
860 {
861         return (strncmp(ea->name, XATTR_TRUSTED_PREFIX,
862                             XATTR_TRUSTED_PREFIX_LEN) ||
863                 capable(CAP_SYS_ADMIN));
864 }
865 
866 ssize_t jfs_listxattr(struct dentry * dentry, char *data, size_t buf_size)
867 {
868         struct inode *inode = d_inode(dentry);
869         char *buffer;
870         ssize_t size = 0;
871         int xattr_size;
872         struct jfs_ea_list *ealist;
873         struct jfs_ea *ea;
874         struct ea_buffer ea_buf;
875 
876         down_read(&JFS_IP(inode)->xattr_sem);
877 
878         xattr_size = ea_get(inode, &ea_buf, 0);
879         if (xattr_size < 0) {
880                 size = xattr_size;
881                 goto out;
882         }
883 
884         if (xattr_size == 0)
885                 goto release;
886 
887         ealist = (struct jfs_ea_list *) ea_buf.xattr;
888 
889         /* compute required size of list */
890         for (ea = FIRST_EA(ealist); ea < END_EALIST(ealist); ea = NEXT_EA(ea)) {
891                 if (can_list(ea))
892                         size += name_size(ea) + 1;
893         }
894 
895         if (!data)
896                 goto release;
897 
898         if (size > buf_size) {
899                 size = -ERANGE;
900                 goto release;
901         }
902 
903         /* Copy attribute names to buffer */
904         buffer = data;
905         for (ea = FIRST_EA(ealist); ea < END_EALIST(ealist); ea = NEXT_EA(ea)) {
906                 if (can_list(ea)) {
907                         int namelen = copy_name(buffer, ea);
908                         buffer += namelen + 1;
909                 }
910         }
911 
912       release:
913         ea_release(inode, &ea_buf);
914       out:
915         up_read(&JFS_IP(inode)->xattr_sem);
916         return size;
917 }
918 
919 static int __jfs_xattr_set(struct inode *inode, const char *name,
920                            const void *value, size_t size, int flags)
921 {
922         struct jfs_inode_info *ji = JFS_IP(inode);
923         tid_t tid;
924         int rc;
925 
926         tid = txBegin(inode->i_sb, 0);
927         mutex_lock(&ji->commit_mutex);
928         rc = __jfs_setxattr(tid, inode, name, value, size, flags);
929         if (!rc)
930                 rc = txCommit(tid, 1, &inode, 0);
931         txEnd(tid);
932         mutex_unlock(&ji->commit_mutex);
933 
934         return rc;
935 }
936 
937 static int jfs_xattr_get(const struct xattr_handler *handler,
938                          struct dentry *unused, struct inode *inode,
939                          const char *name, void *value, size_t size)
940 {
941         name = xattr_full_name(handler, name);
942         return __jfs_getxattr(inode, name, value, size);
943 }
944 
945 static int jfs_xattr_set(const struct xattr_handler *handler,
946                          struct dentry *unused, struct inode *inode,
947                          const char *name, const void *value,
948                          size_t size, int flags)
949 {
950         name = xattr_full_name(handler, name);
951         return __jfs_xattr_set(inode, name, value, size, flags);
952 }
953 
954 static int jfs_xattr_get_os2(const struct xattr_handler *handler,
955                              struct dentry *unused, struct inode *inode,
956                              const char *name, void *value, size_t size)
957 {
958         if (is_known_namespace(name))
959                 return -EOPNOTSUPP;
960         return __jfs_getxattr(inode, name, value, size);
961 }
962 
963 static int jfs_xattr_set_os2(const struct xattr_handler *handler,
964                              struct dentry *unused, struct inode *inode,
965                              const char *name, const void *value,
966                              size_t size, int flags)
967 {
968         if (is_known_namespace(name))
969                 return -EOPNOTSUPP;
970         return __jfs_xattr_set(inode, name, value, size, flags);
971 }
972 
973 static const struct xattr_handler jfs_user_xattr_handler = {
974         .prefix = XATTR_USER_PREFIX,
975         .get = jfs_xattr_get,
976         .set = jfs_xattr_set,
977 };
978 
979 static const struct xattr_handler jfs_os2_xattr_handler = {
980         .prefix = XATTR_OS2_PREFIX,
981         .get = jfs_xattr_get_os2,
982         .set = jfs_xattr_set_os2,
983 };
984 
985 static const struct xattr_handler jfs_security_xattr_handler = {
986         .prefix = XATTR_SECURITY_PREFIX,
987         .get = jfs_xattr_get,
988         .set = jfs_xattr_set,
989 };
990 
991 static const struct xattr_handler jfs_trusted_xattr_handler = {
992         .prefix = XATTR_TRUSTED_PREFIX,
993         .get = jfs_xattr_get,
994         .set = jfs_xattr_set,
995 };
996 
997 const struct xattr_handler *jfs_xattr_handlers[] = {
998 #ifdef CONFIG_JFS_POSIX_ACL
999         &posix_acl_access_xattr_handler,
1000         &posix_acl_default_xattr_handler,
1001 #endif
1002         &jfs_os2_xattr_handler,
1003         &jfs_user_xattr_handler,
1004         &jfs_security_xattr_handler,
1005         &jfs_trusted_xattr_handler,
1006         NULL,
1007 };
1008 
1009 
1010 #ifdef CONFIG_JFS_SECURITY
1011 static int jfs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
1012                           void *fs_info)
1013 {
1014         const struct xattr *xattr;
1015         tid_t *tid = fs_info;
1016         char *name;
1017         int err = 0;
1018 
1019         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
1020                 name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
1021                                strlen(xattr->name) + 1, GFP_NOFS);
1022                 if (!name) {
1023                         err = -ENOMEM;
1024                         break;
1025                 }
1026                 strcpy(name, XATTR_SECURITY_PREFIX);
1027                 strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
1028 
1029                 err = __jfs_setxattr(*tid, inode, name,
1030                                      xattr->value, xattr->value_len, 0);
1031                 kfree(name);
1032                 if (err < 0)
1033                         break;
1034         }
1035         return err;
1036 }
1037 
1038 int jfs_init_security(tid_t tid, struct inode *inode, struct inode *dir,
1039                       const struct qstr *qstr)
1040 {
1041         return security_inode_init_security(inode, dir, qstr,
1042                                             &jfs_initxattrs, &tid);
1043 }
1044 #endif
1045 

~ [ 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