1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
7 #include <linux/slab.h>
8 #include <linux/spinlock.h>
9 #include <linux/completion.h>
10 #include <linux/buffer_head.h>
11 #include <linux/xattr.h>
12 #include <linux/gfs2_ondisk.h>
13 #include <linux/posix_acl_xattr.h>
14 #include <linux/uaccess.h>
30 * ea_calc_size - returns the acutal number of bytes the request will take up
31 * (not counting any unstuffed data blocks)
36 * Returns: 1 if the EA should be stuffed
39 static int ea_calc_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
,
42 unsigned int jbsize
= sdp
->sd_jbsize
;
45 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+ dsize
, 8);
51 *size
= ALIGN(sizeof(struct gfs2_ea_header
) + nsize
+
52 (sizeof(__be64
) * DIV_ROUND_UP(dsize
, jbsize
)), 8);
57 static int ea_check_size(struct gfs2_sbd
*sdp
, unsigned int nsize
, size_t dsize
)
61 if (dsize
> GFS2_EA_MAX_DATA_LEN
)
64 ea_calc_size(sdp
, nsize
, dsize
, &size
);
66 /* This can only happen with 512 byte blocks */
67 if (size
> sdp
->sd_jbsize
)
73 static bool gfs2_eatype_valid(struct gfs2_sbd
*sdp
, u8 type
)
75 switch(sdp
->sd_sb
.sb_fs_format
) {
76 case GFS2_FS_FORMAT_MAX
:
79 case GFS2_FS_FORMAT_MIN
:
80 return type
<= GFS2_EATYPE_SECURITY
;
87 typedef int (*ea_call_t
) (struct gfs2_inode
*ip
, struct buffer_head
*bh
,
88 struct gfs2_ea_header
*ea
,
89 struct gfs2_ea_header
*prev
, void *private);
91 static int ea_foreach_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
92 ea_call_t ea_call
, void *data
)
94 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
95 struct gfs2_ea_header
*ea
, *prev
= NULL
;
98 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_EA
))
101 for (ea
= GFS2_EA_BH2FIRST(bh
);; prev
= ea
, ea
= GFS2_EA2NEXT(ea
)) {
102 if (!GFS2_EA_REC_LEN(ea
))
104 if (!(bh
->b_data
<= (char *)ea
&& (char *)GFS2_EA2NEXT(ea
) <=
105 bh
->b_data
+ bh
->b_size
))
107 if (!gfs2_eatype_valid(sdp
, ea
->ea_type
))
109 error
= ea_call(ip
, bh
, ea
, prev
, data
);
113 if (GFS2_EA_IS_LAST(ea
)) {
114 if ((char *)GFS2_EA2NEXT(ea
) !=
115 bh
->b_data
+ bh
->b_size
)
124 gfs2_consist_inode(ip
);
128 static int ea_foreach(struct gfs2_inode
*ip
, ea_call_t ea_call
, void *data
)
130 struct buffer_head
*bh
, *eabh
;
134 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, 0, &bh
);
138 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
)) {
139 error
= ea_foreach_i(ip
, bh
, ea_call
, data
);
143 if (gfs2_metatype_check(GFS2_SB(&ip
->i_inode
), bh
, GFS2_METATYPE_IN
)) {
148 eablk
= (__be64
*)(bh
->b_data
+ sizeof(struct gfs2_meta_header
));
149 end
= eablk
+ GFS2_SB(&ip
->i_inode
)->sd_inptrs
;
151 for (; eablk
< end
; eablk
++) {
156 bn
= be64_to_cpu(*eablk
);
158 error
= gfs2_meta_read(ip
->i_gl
, bn
, DIO_WAIT
, 0, &eabh
);
161 error
= ea_foreach_i(ip
, eabh
, ea_call
, data
);
175 struct gfs2_ea_location
*ef_el
;
178 static int ea_find_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
179 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
182 struct ea_find
*ef
= private;
184 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
187 if (ea
->ea_type
== ef
->type
) {
188 if (ea
->ea_name_len
== ef
->namel
&&
189 !memcmp(GFS2_EA2NAME(ea
), ef
->name
, ea
->ea_name_len
)) {
190 struct gfs2_ea_location
*el
= ef
->ef_el
;
202 static int gfs2_ea_find(struct gfs2_inode
*ip
, int type
, const char *name
,
203 struct gfs2_ea_location
*el
)
210 ef
.namel
= strlen(name
);
213 memset(el
, 0, sizeof(struct gfs2_ea_location
));
215 error
= ea_foreach(ip
, ea_find_i
, &ef
);
223 * ea_dealloc_unstuffed -
230 * Take advantage of the fact that all unstuffed blocks are
231 * allocated from the same RG. But watch, this may not always
237 static int ea_dealloc_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
238 struct gfs2_ea_header
*ea
,
239 struct gfs2_ea_header
*prev
, void *private)
241 int *leave
= private;
242 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
243 struct gfs2_rgrpd
*rgd
;
244 struct gfs2_holder rg_gh
;
248 unsigned int blen
= 0;
249 unsigned int blks
= 0;
253 error
= gfs2_rindex_update(sdp
);
257 if (GFS2_EA_IS_STUFFED(ea
))
260 dataptrs
= GFS2_EA2DATAPTRS(ea
);
261 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
264 bn
= be64_to_cpu(*dataptrs
);
270 rgd
= gfs2_blk2rgrpd(sdp
, bn
, 1);
272 gfs2_consist_inode(ip
);
276 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
,
277 LM_FLAG_NODE_SCOPE
, &rg_gh
);
281 error
= gfs2_trans_begin(sdp
, rgd
->rd_length
+ RES_DINODE
+
282 RES_EATTR
+ RES_STATFS
+ RES_QUOTA
, blks
);
286 gfs2_trans_add_meta(ip
->i_gl
, bh
);
288 dataptrs
= GFS2_EA2DATAPTRS(ea
);
289 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++, dataptrs
++) {
292 bn
= be64_to_cpu(*dataptrs
);
294 if (bstart
+ blen
== bn
)
298 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
304 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
307 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
309 if (prev
&& !leave
) {
312 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
313 prev
->ea_rec_len
= cpu_to_be32(len
);
315 if (GFS2_EA_IS_LAST(ea
))
316 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
318 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
322 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
323 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
328 gfs2_glock_dq_uninit(&rg_gh
);
332 static int ea_remove_unstuffed(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
333 struct gfs2_ea_header
*ea
,
334 struct gfs2_ea_header
*prev
, int leave
)
338 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
342 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
346 error
= ea_dealloc_unstuffed(ip
, bh
, ea
, prev
, (leave
) ? &error
: NULL
);
348 gfs2_quota_unhold(ip
);
354 struct gfs2_ea_request
*ei_er
;
355 unsigned int ei_size
;
358 static int ea_list_i(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
359 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
362 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
363 struct ea_list
*ei
= private;
364 struct gfs2_ea_request
*er
= ei
->ei_er
;
365 unsigned int ea_size
;
369 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
)
372 BUG_ON(ea
->ea_type
> GFS2_EATYPE_SECURITY
&&
373 sdp
->sd_sb
.sb_fs_format
== GFS2_FS_FORMAT_MIN
);
374 switch (ea
->ea_type
) {
375 case GFS2_EATYPE_USR
:
379 case GFS2_EATYPE_SYS
:
383 case GFS2_EATYPE_SECURITY
:
384 prefix
= "security.";
387 case GFS2_EATYPE_TRUSTED
:
395 ea_size
= l
+ ea
->ea_name_len
+ 1;
396 if (er
->er_data_len
) {
397 if (ei
->ei_size
+ ea_size
> er
->er_data_len
)
400 memcpy(er
->er_data
+ ei
->ei_size
, prefix
, l
);
401 memcpy(er
->er_data
+ ei
->ei_size
+ l
, GFS2_EA2NAME(ea
),
403 er
->er_data
[ei
->ei_size
+ ea_size
- 1] = 0;
406 ei
->ei_size
+= ea_size
;
412 * gfs2_listxattr - List gfs2 extended attributes
413 * @dentry: The dentry whose inode we are interested in
414 * @buffer: The buffer to write the results
415 * @size: The size of the buffer
417 * Returns: actual size of data on success, -errno on error
420 ssize_t
gfs2_listxattr(struct dentry
*dentry
, char *buffer
, size_t size
)
422 struct gfs2_inode
*ip
= GFS2_I(d_inode(dentry
));
423 struct gfs2_ea_request er
;
424 struct gfs2_holder i_gh
;
427 memset(&er
, 0, sizeof(struct gfs2_ea_request
));
430 er
.er_data_len
= size
;
433 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &i_gh
);
438 struct ea_list ei
= { .ei_er
= &er
, .ei_size
= 0 };
440 error
= ea_foreach(ip
, ea_list_i
, &ei
);
445 gfs2_glock_dq_uninit(&i_gh
);
451 * ea_iter_unstuffed - copies the unstuffed xattr data to/from the
453 * @ip: The GFS2 inode
454 * @ea: The extended attribute header structure
455 * @din: The data to be copied in
456 * @dout: The data to be copied out (one of din,dout will be NULL)
461 static int gfs2_iter_unstuffed(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
462 const char *din
, char *dout
)
464 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
465 struct buffer_head
**bh
;
466 unsigned int amount
= GFS2_EA_DATA_LEN(ea
);
467 unsigned int nptrs
= DIV_ROUND_UP(amount
, sdp
->sd_jbsize
);
468 __be64
*dataptrs
= GFS2_EA2DATAPTRS(ea
);
474 bh
= kcalloc(nptrs
, sizeof(struct buffer_head
*), GFP_NOFS
);
478 for (x
= 0; x
< nptrs
; x
++) {
479 error
= gfs2_meta_read(ip
->i_gl
, be64_to_cpu(*dataptrs
), 0, 0,
489 for (x
= 0; x
< nptrs
; x
++) {
490 error
= gfs2_meta_wait(sdp
, bh
[x
]);
492 for (; x
< nptrs
; x
++)
496 if (gfs2_metatype_check(sdp
, bh
[x
], GFS2_METATYPE_ED
)) {
497 for (; x
< nptrs
; x
++)
503 pos
= bh
[x
]->b_data
+ sizeof(struct gfs2_meta_header
);
504 cp_size
= (sdp
->sd_jbsize
> amount
) ? amount
: sdp
->sd_jbsize
;
507 memcpy(dout
, pos
, cp_size
);
508 dout
+= sdp
->sd_jbsize
;
512 gfs2_trans_add_meta(ip
->i_gl
, bh
[x
]);
513 memcpy(pos
, din
, cp_size
);
514 din
+= sdp
->sd_jbsize
;
517 amount
-= sdp
->sd_jbsize
;
526 static int gfs2_ea_get_copy(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
,
527 char *data
, size_t size
)
530 size_t len
= GFS2_EA_DATA_LEN(el
->el_ea
);
534 if (GFS2_EA_IS_STUFFED(el
->el_ea
)) {
535 memcpy(data
, GFS2_EA2DATA(el
->el_ea
), len
);
538 ret
= gfs2_iter_unstuffed(ip
, el
->el_ea
, NULL
, data
);
544 int gfs2_xattr_acl_get(struct gfs2_inode
*ip
, const char *name
, char **ppdata
)
546 struct gfs2_ea_location el
;
551 error
= gfs2_ea_find(ip
, GFS2_EATYPE_SYS
, name
, &el
);
556 if (!GFS2_EA_DATA_LEN(el
.el_ea
))
559 len
= GFS2_EA_DATA_LEN(el
.el_ea
);
560 data
= kmalloc(len
, GFP_NOFS
);
565 error
= gfs2_ea_get_copy(ip
, &el
, data
, len
);
576 * gfs2_xattr_get - Get a GFS2 extended attribute
578 * @name: The name of the extended attribute
579 * @buffer: The buffer to write the result into
580 * @size: The size of the buffer
581 * @type: The type of extended attribute
583 * Returns: actual size of data on success, -errno on error
585 static int __gfs2_xattr_get(struct inode
*inode
, const char *name
,
586 void *buffer
, size_t size
, int type
)
588 struct gfs2_inode
*ip
= GFS2_I(inode
);
589 struct gfs2_ea_location el
;
594 if (strlen(name
) > GFS2_EA_MAX_NAME_LEN
)
597 error
= gfs2_ea_find(ip
, type
, name
, &el
);
603 error
= gfs2_ea_get_copy(ip
, &el
, buffer
, size
);
605 error
= GFS2_EA_DATA_LEN(el
.el_ea
);
611 static int gfs2_xattr_get(const struct xattr_handler
*handler
,
612 struct dentry
*unused
, struct inode
*inode
,
613 const char *name
, void *buffer
, size_t size
)
615 struct gfs2_inode
*ip
= GFS2_I(inode
);
616 struct gfs2_holder gh
;
619 /* During lookup, SELinux calls this function with the glock locked. */
621 if (!gfs2_glock_is_locked_by_me(ip
->i_gl
)) {
622 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
, &gh
);
626 gfs2_holder_mark_uninitialized(&gh
);
628 ret
= __gfs2_xattr_get(inode
, name
, buffer
, size
, handler
->flags
);
629 if (gfs2_holder_initialized(&gh
))
630 gfs2_glock_dq_uninit(&gh
);
635 * ea_alloc_blk - allocates a new block for extended attributes.
636 * @ip: A pointer to the inode that's getting extended attributes
637 * @bhp: Pointer to pointer to a struct buffer_head
642 static int ea_alloc_blk(struct gfs2_inode
*ip
, struct buffer_head
**bhp
)
644 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
645 struct gfs2_ea_header
*ea
;
650 error
= gfs2_alloc_blocks(ip
, &block
, &n
, 0, NULL
);
653 gfs2_trans_remove_revoke(sdp
, block
, 1);
654 *bhp
= gfs2_meta_new(ip
->i_gl
, block
);
655 gfs2_trans_add_meta(ip
->i_gl
, *bhp
);
656 gfs2_metatype_set(*bhp
, GFS2_METATYPE_EA
, GFS2_FORMAT_EA
);
657 gfs2_buffer_clear_tail(*bhp
, sizeof(struct gfs2_meta_header
));
659 ea
= GFS2_EA_BH2FIRST(*bhp
);
660 ea
->ea_rec_len
= cpu_to_be32(sdp
->sd_jbsize
);
661 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
662 ea
->ea_flags
= GFS2_EAFLAG_LAST
;
665 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
671 * ea_write - writes the request info to an ea, creating new blocks if
673 * @ip: inode that is being modified
674 * @ea: the location of the new ea in a block
675 * @er: the write request
677 * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
682 static int ea_write(struct gfs2_inode
*ip
, struct gfs2_ea_header
*ea
,
683 struct gfs2_ea_request
*er
)
685 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
688 ea
->ea_data_len
= cpu_to_be32(er
->er_data_len
);
689 ea
->ea_name_len
= er
->er_name_len
;
690 ea
->ea_type
= er
->er_type
;
693 memcpy(GFS2_EA2NAME(ea
), er
->er_name
, er
->er_name_len
);
695 if (GFS2_EAREQ_SIZE_STUFFED(er
) <= sdp
->sd_jbsize
) {
697 memcpy(GFS2_EA2DATA(ea
), er
->er_data
, er
->er_data_len
);
699 __be64
*dataptr
= GFS2_EA2DATAPTRS(ea
);
700 const char *data
= er
->er_data
;
701 unsigned int data_len
= er
->er_data_len
;
705 ea
->ea_num_ptrs
= DIV_ROUND_UP(er
->er_data_len
, sdp
->sd_jbsize
);
706 for (x
= 0; x
< ea
->ea_num_ptrs
; x
++) {
707 struct buffer_head
*bh
;
709 int mh_size
= sizeof(struct gfs2_meta_header
);
712 error
= gfs2_alloc_blocks(ip
, &block
, &n
, 0, NULL
);
715 gfs2_trans_remove_revoke(sdp
, block
, 1);
716 bh
= gfs2_meta_new(ip
->i_gl
, block
);
717 gfs2_trans_add_meta(ip
->i_gl
, bh
);
718 gfs2_metatype_set(bh
, GFS2_METATYPE_ED
, GFS2_FORMAT_ED
);
720 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
722 copy
= data_len
> sdp
->sd_jbsize
? sdp
->sd_jbsize
:
724 memcpy(bh
->b_data
+ mh_size
, data
, copy
);
725 if (copy
< sdp
->sd_jbsize
)
726 memset(bh
->b_data
+ mh_size
+ copy
, 0,
727 sdp
->sd_jbsize
- copy
);
729 *dataptr
++ = cpu_to_be64(bh
->b_blocknr
);
736 gfs2_assert_withdraw(sdp
, !data_len
);
742 typedef int (*ea_skeleton_call_t
) (struct gfs2_inode
*ip
,
743 struct gfs2_ea_request
*er
, void *private);
745 static int ea_alloc_skeleton(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
747 ea_skeleton_call_t skeleton_call
, void *private)
749 struct gfs2_alloc_parms ap
= { .target
= blks
};
752 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
756 error
= gfs2_quota_lock_check(ip
, &ap
);
760 error
= gfs2_inplace_reserve(ip
, &ap
);
764 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
),
765 blks
+ gfs2_rg_blocks(ip
, blks
) +
766 RES_DINODE
+ RES_STATFS
+ RES_QUOTA
, 0);
770 error
= skeleton_call(ip
, er
, private);
774 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
775 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
778 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
780 gfs2_inplace_release(ip
);
782 gfs2_quota_unlock(ip
);
786 static int ea_init_i(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
789 struct buffer_head
*bh
;
792 error
= ea_alloc_blk(ip
, &bh
);
796 ip
->i_eattr
= bh
->b_blocknr
;
797 error
= ea_write(ip
, GFS2_EA_BH2FIRST(bh
), er
);
805 * ea_init - initializes a new eattr block
812 static int ea_init(struct gfs2_inode
*ip
, int type
, const char *name
,
813 const void *data
, size_t size
)
815 struct gfs2_ea_request er
;
816 unsigned int jbsize
= GFS2_SB(&ip
->i_inode
)->sd_jbsize
;
817 unsigned int blks
= 1;
821 er
.er_name_len
= strlen(name
);
822 er
.er_data
= (void *)data
;
823 er
.er_data_len
= size
;
825 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > jbsize
)
826 blks
+= DIV_ROUND_UP(er
.er_data_len
, jbsize
);
828 return ea_alloc_skeleton(ip
, &er
, blks
, ea_init_i
, NULL
);
831 static struct gfs2_ea_header
*ea_split_ea(struct gfs2_ea_header
*ea
)
833 u32 ea_size
= GFS2_EA_SIZE(ea
);
834 struct gfs2_ea_header
*new = (struct gfs2_ea_header
*)((char *)ea
+
836 u32 new_size
= GFS2_EA_REC_LEN(ea
) - ea_size
;
837 int last
= ea
->ea_flags
& GFS2_EAFLAG_LAST
;
839 ea
->ea_rec_len
= cpu_to_be32(ea_size
);
840 ea
->ea_flags
^= last
;
842 new->ea_rec_len
= cpu_to_be32(new_size
);
843 new->ea_flags
= last
;
848 static void ea_set_remove_stuffed(struct gfs2_inode
*ip
,
849 struct gfs2_ea_location
*el
)
851 struct gfs2_ea_header
*ea
= el
->el_ea
;
852 struct gfs2_ea_header
*prev
= el
->el_prev
;
855 gfs2_trans_add_meta(ip
->i_gl
, el
->el_bh
);
857 if (!prev
|| !GFS2_EA_IS_STUFFED(ea
)) {
858 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
860 } else if (GFS2_EA2NEXT(prev
) != ea
) {
861 prev
= GFS2_EA2NEXT(prev
);
862 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
), GFS2_EA2NEXT(prev
) == ea
);
865 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
866 prev
->ea_rec_len
= cpu_to_be32(len
);
868 if (GFS2_EA_IS_LAST(ea
))
869 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
875 struct gfs2_ea_request
*es_er
;
876 struct gfs2_ea_location
*es_el
;
878 struct buffer_head
*es_bh
;
879 struct gfs2_ea_header
*es_ea
;
882 static int ea_set_simple_noalloc(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
883 struct gfs2_ea_header
*ea
, struct ea_set
*es
)
885 struct gfs2_ea_request
*er
= es
->es_er
;
888 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ 2 * RES_EATTR
, 0);
892 gfs2_trans_add_meta(ip
->i_gl
, bh
);
895 ea
= ea_split_ea(ea
);
897 ea_write(ip
, ea
, er
);
900 ea_set_remove_stuffed(ip
, es
->es_el
);
902 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
903 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
905 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
909 static int ea_set_simple_alloc(struct gfs2_inode
*ip
,
910 struct gfs2_ea_request
*er
, void *private)
912 struct ea_set
*es
= private;
913 struct gfs2_ea_header
*ea
= es
->es_ea
;
916 gfs2_trans_add_meta(ip
->i_gl
, es
->es_bh
);
919 ea
= ea_split_ea(ea
);
921 error
= ea_write(ip
, ea
, er
);
926 ea_set_remove_stuffed(ip
, es
->es_el
);
931 static int ea_set_simple(struct gfs2_inode
*ip
, struct buffer_head
*bh
,
932 struct gfs2_ea_header
*ea
, struct gfs2_ea_header
*prev
,
935 struct ea_set
*es
= private;
940 stuffed
= ea_calc_size(GFS2_SB(&ip
->i_inode
), es
->es_er
->er_name_len
,
941 es
->es_er
->er_data_len
, &size
);
943 if (ea
->ea_type
== GFS2_EATYPE_UNUSED
) {
944 if (GFS2_EA_REC_LEN(ea
) < size
)
946 if (!GFS2_EA_IS_STUFFED(ea
)) {
947 error
= ea_remove_unstuffed(ip
, bh
, ea
, prev
, 1);
952 } else if (GFS2_EA_REC_LEN(ea
) - GFS2_EA_SIZE(ea
) >= size
)
958 error
= ea_set_simple_noalloc(ip
, bh
, ea
, es
);
966 blks
= 2 + DIV_ROUND_UP(es
->es_er
->er_data_len
,
967 GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
969 error
= ea_alloc_skeleton(ip
, es
->es_er
, blks
,
970 ea_set_simple_alloc
, es
);
978 static int ea_set_block(struct gfs2_inode
*ip
, struct gfs2_ea_request
*er
,
981 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
982 struct buffer_head
*indbh
, *newbh
;
985 int mh_size
= sizeof(struct gfs2_meta_header
);
987 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
990 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, 0,
995 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
1000 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
1001 end
= eablk
+ sdp
->sd_inptrs
;
1003 for (; eablk
< end
; eablk
++)
1012 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1016 error
= gfs2_alloc_blocks(ip
, &blk
, &n
, 0, NULL
);
1019 gfs2_trans_remove_revoke(sdp
, blk
, 1);
1020 indbh
= gfs2_meta_new(ip
->i_gl
, blk
);
1021 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1022 gfs2_metatype_set(indbh
, GFS2_METATYPE_IN
, GFS2_FORMAT_IN
);
1023 gfs2_buffer_clear_tail(indbh
, mh_size
);
1025 eablk
= (__be64
*)(indbh
->b_data
+ mh_size
);
1026 *eablk
= cpu_to_be64(ip
->i_eattr
);
1028 ip
->i_diskflags
|= GFS2_DIF_EA_INDIRECT
;
1029 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
1034 error
= ea_alloc_blk(ip
, &newbh
);
1038 *eablk
= cpu_to_be64((u64
)newbh
->b_blocknr
);
1039 error
= ea_write(ip
, GFS2_EA_BH2FIRST(newbh
), er
);
1045 ea_set_remove_stuffed(ip
, private);
1052 static int ea_set_i(struct gfs2_inode
*ip
, int type
, const char *name
,
1053 const void *value
, size_t size
, struct gfs2_ea_location
*el
)
1055 struct gfs2_ea_request er
;
1057 unsigned int blks
= 2;
1062 er
.er_data
= (void *)value
;
1063 er
.er_name_len
= strlen(name
);
1064 er
.er_data_len
= size
;
1066 memset(&es
, 0, sizeof(struct ea_set
));
1070 error
= ea_foreach(ip
, ea_set_simple
, &es
);
1076 if (!(ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
))
1078 if (GFS2_EAREQ_SIZE_STUFFED(&er
) > GFS2_SB(&ip
->i_inode
)->sd_jbsize
)
1079 blks
+= DIV_ROUND_UP(er
.er_data_len
, GFS2_SB(&ip
->i_inode
)->sd_jbsize
);
1081 return ea_alloc_skeleton(ip
, &er
, blks
, ea_set_block
, el
);
1084 static int ea_set_remove_unstuffed(struct gfs2_inode
*ip
,
1085 struct gfs2_ea_location
*el
)
1087 if (el
->el_prev
&& GFS2_EA2NEXT(el
->el_prev
) != el
->el_ea
) {
1088 el
->el_prev
= GFS2_EA2NEXT(el
->el_prev
);
1089 gfs2_assert_withdraw(GFS2_SB(&ip
->i_inode
),
1090 GFS2_EA2NEXT(el
->el_prev
) == el
->el_ea
);
1093 return ea_remove_unstuffed(ip
, el
->el_bh
, el
->el_ea
, el
->el_prev
, 0);
1096 static int ea_remove_stuffed(struct gfs2_inode
*ip
, struct gfs2_ea_location
*el
)
1098 struct gfs2_ea_header
*ea
= el
->el_ea
;
1099 struct gfs2_ea_header
*prev
= el
->el_prev
;
1102 error
= gfs2_trans_begin(GFS2_SB(&ip
->i_inode
), RES_DINODE
+ RES_EATTR
, 0);
1106 gfs2_trans_add_meta(ip
->i_gl
, el
->el_bh
);
1111 len
= GFS2_EA_REC_LEN(prev
) + GFS2_EA_REC_LEN(ea
);
1112 prev
->ea_rec_len
= cpu_to_be32(len
);
1114 if (GFS2_EA_IS_LAST(ea
))
1115 prev
->ea_flags
|= GFS2_EAFLAG_LAST
;
1117 ea
->ea_type
= GFS2_EATYPE_UNUSED
;
1120 ip
->i_inode
.i_ctime
= current_time(&ip
->i_inode
);
1121 __mark_inode_dirty(&ip
->i_inode
, I_DIRTY_DATASYNC
);
1123 gfs2_trans_end(GFS2_SB(&ip
->i_inode
));
1129 * gfs2_xattr_remove - Remove a GFS2 extended attribute
1131 * @type: The type of the extended attribute
1132 * @name: The name of the extended attribute
1134 * This is not called directly by the VFS since we use the (common)
1135 * scheme of making a "set with NULL data" mean a remove request. Note
1136 * that this is different from a set with zero length data.
1138 * Returns: 0, or errno on failure
1141 static int gfs2_xattr_remove(struct gfs2_inode
*ip
, int type
, const char *name
)
1143 struct gfs2_ea_location el
;
1149 error
= gfs2_ea_find(ip
, type
, name
, &el
);
1155 if (GFS2_EA_IS_STUFFED(el
.el_ea
))
1156 error
= ea_remove_stuffed(ip
, &el
);
1158 error
= ea_remove_unstuffed(ip
, el
.el_bh
, el
.el_ea
, el
.el_prev
, 0);
1166 * __gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1168 * @name: The name of the extended attribute
1169 * @value: The value of the extended attribute (NULL for remove)
1170 * @size: The size of the @value argument
1171 * @flags: Create or Replace
1172 * @type: The type of the extended attribute
1174 * See gfs2_xattr_remove() for details of the removal of xattrs.
1176 * Returns: 0 or errno on failure
1179 int __gfs2_xattr_set(struct inode
*inode
, const char *name
,
1180 const void *value
, size_t size
, int flags
, int type
)
1182 struct gfs2_inode
*ip
= GFS2_I(inode
);
1183 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1184 struct gfs2_ea_location el
;
1185 unsigned int namel
= strlen(name
);
1188 if (IS_IMMUTABLE(inode
) || IS_APPEND(inode
))
1190 if (namel
> GFS2_EA_MAX_NAME_LEN
)
1193 if (value
== NULL
) {
1194 error
= gfs2_xattr_remove(ip
, type
, name
);
1195 if (error
== -ENODATA
&& !(flags
& XATTR_REPLACE
))
1200 if (ea_check_size(sdp
, namel
, size
))
1204 if (flags
& XATTR_REPLACE
)
1206 return ea_init(ip
, type
, name
, value
, size
);
1209 error
= gfs2_ea_find(ip
, type
, name
, &el
);
1214 if (ip
->i_diskflags
& GFS2_DIF_APPENDONLY
) {
1220 if (!(flags
& XATTR_CREATE
)) {
1221 int unstuffed
= !GFS2_EA_IS_STUFFED(el
.el_ea
);
1222 error
= ea_set_i(ip
, type
, name
, value
, size
, &el
);
1223 if (!error
&& unstuffed
)
1224 ea_set_remove_unstuffed(ip
, &el
);
1232 if (!(flags
& XATTR_REPLACE
))
1233 error
= ea_set_i(ip
, type
, name
, value
, size
, NULL
);
1238 static int gfs2_xattr_set(const struct xattr_handler
*handler
,
1239 struct user_namespace
*mnt_userns
,
1240 struct dentry
*unused
, struct inode
*inode
,
1241 const char *name
, const void *value
,
1242 size_t size
, int flags
)
1244 struct gfs2_inode
*ip
= GFS2_I(inode
);
1245 struct gfs2_holder gh
;
1248 ret
= gfs2_qa_get(ip
);
1252 /* May be called from gfs_setattr with the glock locked. */
1254 if (!gfs2_glock_is_locked_by_me(ip
->i_gl
)) {
1255 ret
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1259 if (WARN_ON_ONCE(ip
->i_gl
->gl_state
!= LM_ST_EXCLUSIVE
)) {
1263 gfs2_holder_mark_uninitialized(&gh
);
1265 ret
= __gfs2_xattr_set(inode
, name
, value
, size
, flags
, handler
->flags
);
1266 if (gfs2_holder_initialized(&gh
))
1267 gfs2_glock_dq_uninit(&gh
);
1273 static int ea_dealloc_indirect(struct gfs2_inode
*ip
)
1275 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1276 struct gfs2_rgrp_list rlist
;
1277 struct gfs2_rgrpd
*rgd
;
1278 struct buffer_head
*indbh
, *dibh
;
1279 __be64
*eablk
, *end
;
1280 unsigned int rg_blocks
= 0;
1282 unsigned int blen
= 0;
1283 unsigned int blks
= 0;
1287 error
= gfs2_rindex_update(sdp
);
1291 memset(&rlist
, 0, sizeof(struct gfs2_rgrp_list
));
1293 error
= gfs2_meta_read(ip
->i_gl
, ip
->i_eattr
, DIO_WAIT
, 0, &indbh
);
1297 if (gfs2_metatype_check(sdp
, indbh
, GFS2_METATYPE_IN
)) {
1302 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1303 end
= eablk
+ sdp
->sd_inptrs
;
1305 for (; eablk
< end
; eablk
++) {
1310 bn
= be64_to_cpu(*eablk
);
1312 if (bstart
+ blen
== bn
)
1316 gfs2_rlist_add(ip
, &rlist
, bstart
);
1323 gfs2_rlist_add(ip
, &rlist
, bstart
);
1327 gfs2_rlist_alloc(&rlist
);
1329 for (x
= 0; x
< rlist
.rl_rgrps
; x
++) {
1330 rgd
= gfs2_glock2rgrp(rlist
.rl_ghs
[x
].gh_gl
);
1331 rg_blocks
+= rgd
->rd_length
;
1334 error
= gfs2_glock_nq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1336 goto out_rlist_free
;
1338 error
= gfs2_trans_begin(sdp
, rg_blocks
+ RES_DINODE
+ RES_INDIRECT
+
1339 RES_STATFS
+ RES_QUOTA
, blks
);
1343 gfs2_trans_add_meta(ip
->i_gl
, indbh
);
1345 eablk
= (__be64
*)(indbh
->b_data
+ sizeof(struct gfs2_meta_header
));
1350 for (; eablk
< end
; eablk
++) {
1355 bn
= be64_to_cpu(*eablk
);
1357 if (bstart
+ blen
== bn
)
1361 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
1363 rgd
= gfs2_blk2rgrpd(sdp
, bstart
, true);
1368 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1371 gfs2_free_meta(ip
, rgd
, bstart
, blen
);
1373 ip
->i_diskflags
&= ~GFS2_DIF_EA_INDIRECT
;
1375 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1377 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
1378 gfs2_dinode_out(ip
, dibh
->b_data
);
1382 gfs2_trans_end(sdp
);
1385 gfs2_glock_dq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
1387 gfs2_rlist_free(&rlist
);
1393 static int ea_dealloc_block(struct gfs2_inode
*ip
)
1395 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1396 struct gfs2_rgrpd
*rgd
;
1397 struct buffer_head
*dibh
;
1398 struct gfs2_holder gh
;
1401 error
= gfs2_rindex_update(sdp
);
1405 rgd
= gfs2_blk2rgrpd(sdp
, ip
->i_eattr
, 1);
1407 gfs2_consist_inode(ip
);
1411 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
,
1412 LM_FLAG_NODE_SCOPE
, &gh
);
1416 error
= gfs2_trans_begin(sdp
, RES_RG_BIT
+ RES_DINODE
+ RES_STATFS
+
1421 gfs2_free_meta(ip
, rgd
, ip
->i_eattr
, 1);
1424 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
1426 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1428 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
1429 gfs2_dinode_out(ip
, dibh
->b_data
);
1433 gfs2_trans_end(sdp
);
1436 gfs2_glock_dq_uninit(&gh
);
1441 * gfs2_ea_dealloc - deallocate the extended attribute fork
1447 int gfs2_ea_dealloc(struct gfs2_inode
*ip
)
1451 error
= gfs2_rindex_update(GFS2_SB(&ip
->i_inode
));
1455 error
= gfs2_quota_hold(ip
, NO_UID_QUOTA_CHANGE
, NO_GID_QUOTA_CHANGE
);
1459 error
= ea_foreach(ip
, ea_dealloc_unstuffed
, NULL
);
1463 if (ip
->i_diskflags
& GFS2_DIF_EA_INDIRECT
) {
1464 error
= ea_dealloc_indirect(ip
);
1469 error
= ea_dealloc_block(ip
);
1472 gfs2_quota_unhold(ip
);
1476 static const struct xattr_handler gfs2_xattr_user_handler
= {
1477 .prefix
= XATTR_USER_PREFIX
,
1478 .flags
= GFS2_EATYPE_USR
,
1479 .get
= gfs2_xattr_get
,
1480 .set
= gfs2_xattr_set
,
1483 static const struct xattr_handler gfs2_xattr_security_handler
= {
1484 .prefix
= XATTR_SECURITY_PREFIX
,
1485 .flags
= GFS2_EATYPE_SECURITY
,
1486 .get
= gfs2_xattr_get
,
1487 .set
= gfs2_xattr_set
,
1491 gfs2_xattr_trusted_list(struct dentry
*dentry
)
1493 return capable(CAP_SYS_ADMIN
);
1496 static const struct xattr_handler gfs2_xattr_trusted_handler
= {
1497 .prefix
= XATTR_TRUSTED_PREFIX
,
1498 .flags
= GFS2_EATYPE_TRUSTED
,
1499 .list
= gfs2_xattr_trusted_list
,
1500 .get
= gfs2_xattr_get
,
1501 .set
= gfs2_xattr_set
,
1504 const struct xattr_handler
*gfs2_xattr_handlers_max
[] = {
1505 /* GFS2_FS_FORMAT_MAX */
1506 &gfs2_xattr_trusted_handler
,
1508 /* GFS2_FS_FORMAT_MIN */
1509 &gfs2_xattr_user_handler
,
1510 &gfs2_xattr_security_handler
,
1511 &posix_acl_access_xattr_handler
,
1512 &posix_acl_default_xattr_handler
,
1516 const struct xattr_handler
**gfs2_xattr_handlers_min
= gfs2_xattr_handlers_max
+ 1;