9 #include <linux/compat.h>
10 #include <linux/mount.h>
12 #define FS_IOC_GOINGDOWN _IOR('X', 125, __u32)
16 /* bcachefs inode flags -> vfs inode flags: */
17 static const unsigned bch_flags_to_vfs[] = {
18 [__BCH_INODE_SYNC] = S_SYNC,
19 [__BCH_INODE_IMMUTABLE] = S_IMMUTABLE,
20 [__BCH_INODE_APPEND] = S_APPEND,
21 [__BCH_INODE_NOATIME] = S_NOATIME,
24 /* bcachefs inode flags -> FS_IOC_GETFLAGS: */
25 static const unsigned bch_flags_to_uflags[] = {
26 [__BCH_INODE_SYNC] = FS_SYNC_FL,
27 [__BCH_INODE_IMMUTABLE] = FS_IMMUTABLE_FL,
28 [__BCH_INODE_APPEND] = FS_APPEND_FL,
29 [__BCH_INODE_NODUMP] = FS_NODUMP_FL,
30 [__BCH_INODE_NOATIME] = FS_NOATIME_FL,
33 /* bcachefs inode flags -> FS_IOC_FSGETXATTR: */
34 static const unsigned bch_flags_to_xflags[] = {
35 [__BCH_INODE_SYNC] = FS_XFLAG_SYNC,
36 [__BCH_INODE_IMMUTABLE] = FS_XFLAG_IMMUTABLE,
37 [__BCH_INODE_APPEND] = FS_XFLAG_APPEND,
38 [__BCH_INODE_NODUMP] = FS_XFLAG_NODUMP,
39 [__BCH_INODE_NOATIME] = FS_XFLAG_NOATIME,
40 //[__BCH_INODE_PROJINHERIT] = FS_XFLAG_PROJINHERIT;
43 #define set_flags(_map, _in, _out) \
47 for (_i = 0; _i < ARRAY_SIZE(_map); _i++) \
48 if ((_in) & (1 << _i)) \
51 (_out) &= ~_map[_i]; \
54 #define map_flags(_map, _in) \
58 set_flags(_map, _in, _out); \
62 #define map_flags_rev(_map, _in) \
64 unsigned _i, _out = 0; \
66 for (_i = 0; _i < ARRAY_SIZE(_map); _i++) \
67 if ((_in) & _map[_i]) { \
74 #define map_defined(_map) \
78 map_flags_rev(_map, _in); \
81 /* Set VFS inode flags from bcachefs inode: */
82 void bch2_inode_flags_to_vfs(struct bch_inode_info *inode)
84 set_flags(bch_flags_to_vfs, inode->ei_inode.bi_flags, inode->v.i_flags);
92 static int bch2_inode_flags_set(struct bch_inode_info *inode,
93 struct bch_inode_unpacked *bi,
97 * We're relying on btree locking here for exclusion with other ioctl
98 * calls - use the flags in the btree (@bi), not inode->i_flags:
100 struct flags_set *s = p;
101 unsigned newflags = s->flags;
102 unsigned oldflags = bi->bi_flags & s->mask;
104 if (((newflags ^ oldflags) & (BCH_INODE_APPEND|BCH_INODE_IMMUTABLE)) &&
105 !capable(CAP_LINUX_IMMUTABLE))
108 if (!S_ISREG(inode->v.i_mode) &&
109 !S_ISDIR(inode->v.i_mode) &&
110 (newflags & (BCH_INODE_NODUMP|BCH_INODE_NOATIME)) != newflags)
113 bi->bi_flags &= ~s->mask;
114 bi->bi_flags |= newflags;
115 inode->v.i_ctime = current_time(&inode->v);
119 static int bch2_ioc_getflags(struct bch_inode_info *inode, int __user *arg)
121 unsigned flags = map_flags(bch_flags_to_uflags, inode->ei_inode.bi_flags);
123 return put_user(flags, arg);
126 static int bch2_ioc_setflags(struct bch_fs *c,
128 struct bch_inode_info *inode,
131 struct flags_set s = { .mask = map_defined(bch_flags_to_uflags) };
135 if (get_user(uflags, (int __user *) arg))
138 s.flags = map_flags_rev(bch_flags_to_uflags, uflags);
142 ret = mnt_want_write_file(file);
146 inode_lock(&inode->v);
147 if (!inode_owner_or_capable(&inode->v)) {
152 mutex_lock(&inode->ei_update_lock);
153 ret = __bch2_write_inode(c, inode, bch2_inode_flags_set, &s);
156 bch2_inode_flags_to_vfs(inode);
157 mutex_unlock(&inode->ei_update_lock);
160 inode_unlock(&inode->v);
161 mnt_drop_write_file(file);
165 static int bch2_ioc_fsgetxattr(struct bch_inode_info *inode,
166 struct fsxattr __user *arg)
168 struct fsxattr fa = { 0 };
170 fa.fsx_xflags = map_flags(bch_flags_to_xflags, inode->ei_inode.bi_flags);
171 fa.fsx_projid = inode->ei_qid.q[QTYP_PRJ];
173 return copy_to_user(arg, &fa, sizeof(fa));
176 static int bch2_set_projid(struct bch_fs *c,
177 struct bch_inode_info *inode,
180 struct bch_qid qid = inode->ei_qid;
183 if (projid == inode->ei_qid.q[QTYP_PRJ])
186 qid.q[QTYP_PRJ] = projid;
188 ret = bch2_quota_transfer(c, 1 << QTYP_PRJ, qid, inode->ei_qid,
190 inode->ei_quota_reserved);
194 inode->ei_qid.q[QTYP_PRJ] = projid;
198 static int bch2_ioc_fssetxattr(struct bch_fs *c,
200 struct bch_inode_info *inode,
201 struct fsxattr __user *arg)
203 struct flags_set s = { .mask = map_defined(bch_flags_to_xflags) };
207 if (copy_from_user(&fa, arg, sizeof(fa)))
210 s.flags = map_flags_rev(bch_flags_to_xflags, fa.fsx_xflags);
214 ret = mnt_want_write_file(file);
218 inode_lock(&inode->v);
219 if (!inode_owner_or_capable(&inode->v)) {
224 mutex_lock(&inode->ei_update_lock);
225 ret = bch2_set_projid(c, inode, fa.fsx_projid);
229 ret = __bch2_write_inode(c, inode, bch2_inode_flags_set, &s);
231 bch2_inode_flags_to_vfs(inode);
233 mutex_unlock(&inode->ei_update_lock);
235 inode_unlock(&inode->v);
236 mnt_drop_write_file(file);
240 long bch2_fs_file_ioctl(struct file *file, unsigned cmd, unsigned long arg)
242 struct bch_inode_info *inode = file_bch_inode(file);
243 struct super_block *sb = inode->v.i_sb;
244 struct bch_fs *c = sb->s_fs_info;
247 case FS_IOC_GETFLAGS:
248 return bch2_ioc_getflags(inode, (int __user *) arg);
250 case FS_IOC_SETFLAGS:
251 return bch2_ioc_setflags(c, file, inode, (int __user *) arg);
253 case FS_IOC_FSGETXATTR:
254 return bch2_ioc_fsgetxattr(inode, (void __user *) arg);
255 case FS_IOC_FSSETXATTR:
256 return bch2_ioc_fssetxattr(c, file, inode, (void __user *) arg);
258 case FS_IOC_GETVERSION:
260 case FS_IOC_SETVERSION:
263 case FS_IOC_GOINGDOWN:
264 if (!capable(CAP_SYS_ADMIN))
267 down_write(&sb->s_umount);
268 sb->s_flags |= MS_RDONLY;
269 bch2_fs_emergency_read_only(c);
270 up_write(&sb->s_umount);
274 return bch2_fs_ioctl(c, cmd, (void __user *) arg);
279 long bch2_compat_fs_ioctl(struct file *file, unsigned cmd, unsigned long arg)
281 /* These are just misnamed, they actually get/put from/to user an int */
283 case FS_IOC_GETFLAGS:
284 cmd = FS_IOC_GETFLAGS;
286 case FS_IOC32_SETFLAGS:
287 cmd = FS_IOC_SETFLAGS;
292 return bch2_fs_file_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
296 #endif /* NO_BCACHEFS_FS */