GNU Linux-libre 5.10.219-gnu1
[releases.git] / fs / hfs / attr.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/fs/hfs/attr.c
4  *
5  * (C) 2003 Ardis Technologies <roman@ardistech.com>
6  *
7  * Export hfs data via xattr
8  */
9
10
11 #include <linux/fs.h>
12 #include <linux/xattr.h>
13
14 #include "hfs_fs.h"
15 #include "btree.h"
16
17 enum hfs_xattr_type {
18         HFS_TYPE,
19         HFS_CREATOR,
20 };
21
22 static int __hfs_setxattr(struct inode *inode, enum hfs_xattr_type type,
23                           const void *value, size_t size, int flags)
24 {
25         struct hfs_find_data fd;
26         hfs_cat_rec rec;
27         struct hfs_cat_file *file;
28         int res;
29
30         if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode))
31                 return -EOPNOTSUPP;
32
33         res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
34         if (res)
35                 return res;
36         fd.search_key->cat = HFS_I(inode)->cat_key;
37         res = hfs_brec_find(&fd);
38         if (res)
39                 goto out;
40         hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
41                         sizeof(struct hfs_cat_file));
42         file = &rec.file;
43
44         switch (type) {
45         case HFS_TYPE:
46                 if (size == 4)
47                         memcpy(&file->UsrWds.fdType, value, 4);
48                 else
49                         res = -ERANGE;
50                 break;
51
52         case HFS_CREATOR:
53                 if (size == 4)
54                         memcpy(&file->UsrWds.fdCreator, value, 4);
55                 else
56                         res = -ERANGE;
57                 break;
58         }
59
60         if (!res)
61                 hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
62                                 sizeof(struct hfs_cat_file));
63 out:
64         hfs_find_exit(&fd);
65         return res;
66 }
67
68 static ssize_t __hfs_getxattr(struct inode *inode, enum hfs_xattr_type type,
69                               void *value, size_t size)
70 {
71         struct hfs_find_data fd;
72         hfs_cat_rec rec;
73         struct hfs_cat_file *file;
74         ssize_t res = 0;
75
76         if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode))
77                 return -EOPNOTSUPP;
78
79         if (size) {
80                 res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
81                 if (res)
82                         return res;
83                 fd.search_key->cat = HFS_I(inode)->cat_key;
84                 res = hfs_brec_find(&fd);
85                 if (res)
86                         goto out;
87                 hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
88                                 sizeof(struct hfs_cat_file));
89         }
90         file = &rec.file;
91
92         switch (type) {
93         case HFS_TYPE:
94                 if (size >= 4) {
95                         memcpy(value, &file->UsrWds.fdType, 4);
96                         res = 4;
97                 } else
98                         res = size ? -ERANGE : 4;
99                 break;
100
101         case HFS_CREATOR:
102                 if (size >= 4) {
103                         memcpy(value, &file->UsrWds.fdCreator, 4);
104                         res = 4;
105                 } else
106                         res = size ? -ERANGE : 4;
107                 break;
108         }
109
110 out:
111         if (size)
112                 hfs_find_exit(&fd);
113         return res;
114 }
115
116 static int hfs_xattr_get(const struct xattr_handler *handler,
117                          struct dentry *unused, struct inode *inode,
118                          const char *name, void *value, size_t size)
119 {
120         return __hfs_getxattr(inode, handler->flags, value, size);
121 }
122
123 static int hfs_xattr_set(const struct xattr_handler *handler,
124                          struct dentry *unused, struct inode *inode,
125                          const char *name, const void *value, size_t size,
126                          int flags)
127 {
128         if (!value)
129                 return -EOPNOTSUPP;
130
131         return __hfs_setxattr(inode, handler->flags, value, size, flags);
132 }
133
134 static const struct xattr_handler hfs_creator_handler = {
135         .name = "hfs.creator",
136         .flags = HFS_CREATOR,
137         .get = hfs_xattr_get,
138         .set = hfs_xattr_set,
139 };
140
141 static const struct xattr_handler hfs_type_handler = {
142         .name = "hfs.type",
143         .flags = HFS_TYPE,
144         .get = hfs_xattr_get,
145         .set = hfs_xattr_set,
146 };
147
148 const struct xattr_handler *hfs_xattr_handlers[] = {
149         &hfs_creator_handler,
150         &hfs_type_handler,
151         NULL
152 };