1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/ceph/ceph_debug.h>
6 #include "mds_client.h"
8 #include <linux/ceph/striper.h>
9 #include <linux/fscrypt.h>
16 * get and set the file layout
18 static long ceph_ioctl_get_layout(struct file *file, void __user *arg)
20 struct ceph_inode_info *ci = ceph_inode(file_inode(file));
21 struct ceph_ioctl_layout l;
24 err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT, false);
26 l.stripe_unit = ci->i_layout.stripe_unit;
27 l.stripe_count = ci->i_layout.stripe_count;
28 l.object_size = ci->i_layout.object_size;
29 l.data_pool = ci->i_layout.pool_id;
31 if (copy_to_user(arg, &l, sizeof(l)))
38 static long __validate_layout(struct ceph_mds_client *mdsc,
39 struct ceph_ioctl_layout *l)
43 /* validate striping parameters */
44 if ((l->object_size & ~PAGE_MASK) ||
45 (l->stripe_unit & ~PAGE_MASK) ||
46 ((unsigned)l->stripe_unit != 0 &&
47 ((unsigned)l->object_size % (unsigned)l->stripe_unit)))
50 /* make sure it's a valid data pool */
51 mutex_lock(&mdsc->mutex);
53 for (i = 0; i < mdsc->mdsmap->m_num_data_pg_pools; i++)
54 if (mdsc->mdsmap->m_data_pg_pools[i] == l->data_pool) {
58 mutex_unlock(&mdsc->mutex);
65 static long ceph_ioctl_set_layout(struct file *file, void __user *arg)
67 struct inode *inode = file_inode(file);
68 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
69 struct ceph_mds_request *req;
70 struct ceph_ioctl_layout l;
71 struct ceph_inode_info *ci = ceph_inode(file_inode(file));
72 struct ceph_ioctl_layout nl;
75 if (copy_from_user(&l, arg, sizeof(l)))
78 /* validate changed params against current layout */
79 err = ceph_do_getattr(file_inode(file), CEPH_STAT_CAP_LAYOUT, false);
83 memset(&nl, 0, sizeof(nl));
85 nl.stripe_count = l.stripe_count;
87 nl.stripe_count = ci->i_layout.stripe_count;
89 nl.stripe_unit = l.stripe_unit;
91 nl.stripe_unit = ci->i_layout.stripe_unit;
93 nl.object_size = l.object_size;
95 nl.object_size = ci->i_layout.object_size;
97 nl.data_pool = l.data_pool;
99 nl.data_pool = ci->i_layout.pool_id;
101 /* this is obsolete, and always -1 */
102 nl.preferred_osd = -1;
104 err = __validate_layout(mdsc, &nl);
108 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETLAYOUT,
112 req->r_inode = inode;
116 req->r_inode_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL;
118 req->r_args.setlayout.layout.fl_stripe_unit =
119 cpu_to_le32(l.stripe_unit);
120 req->r_args.setlayout.layout.fl_stripe_count =
121 cpu_to_le32(l.stripe_count);
122 req->r_args.setlayout.layout.fl_object_size =
123 cpu_to_le32(l.object_size);
124 req->r_args.setlayout.layout.fl_pg_pool = cpu_to_le32(l.data_pool);
126 err = ceph_mdsc_do_request(mdsc, NULL, req);
127 ceph_mdsc_put_request(req);
132 * Set a layout policy on a directory inode. All items in the tree
133 * rooted at this inode will inherit this layout on creation,
134 * (It doesn't apply retroactively )
135 * unless a subdirectory has its own layout policy.
137 static long ceph_ioctl_set_layout_policy (struct file *file, void __user *arg)
139 struct inode *inode = file_inode(file);
140 struct ceph_mds_request *req;
141 struct ceph_ioctl_layout l;
143 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
145 /* copy and validate */
146 if (copy_from_user(&l, arg, sizeof(l)))
149 err = __validate_layout(mdsc, &l);
153 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETDIRLAYOUT,
158 req->r_inode = inode;
162 req->r_args.setlayout.layout.fl_stripe_unit =
163 cpu_to_le32(l.stripe_unit);
164 req->r_args.setlayout.layout.fl_stripe_count =
165 cpu_to_le32(l.stripe_count);
166 req->r_args.setlayout.layout.fl_object_size =
167 cpu_to_le32(l.object_size);
168 req->r_args.setlayout.layout.fl_pg_pool =
169 cpu_to_le32(l.data_pool);
171 err = ceph_mdsc_do_request(mdsc, inode, req);
172 ceph_mdsc_put_request(req);
177 * Return object name, size/offset information, and location (OSD
178 * number, network address) for a given file offset.
180 static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
182 struct ceph_ioctl_dataloc dl;
183 struct inode *inode = file_inode(file);
184 struct ceph_inode_info *ci = ceph_inode(inode);
185 struct ceph_osd_client *osdc =
186 &ceph_sb_to_client(inode->i_sb)->client->osdc;
187 struct ceph_object_locator oloc;
188 CEPH_DEFINE_OID_ONSTACK(oid);
194 /* copy and validate */
195 if (copy_from_user(&dl, arg, sizeof(dl)))
198 down_read(&osdc->lock);
199 ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, 1,
200 &dl.object_no, &dl.object_offset, &xlen);
201 dl.file_offset -= dl.object_offset;
202 dl.object_size = ci->i_layout.object_size;
203 dl.block_size = ci->i_layout.stripe_unit;
205 /* block_offset = object_offset % block_size */
206 tmp = dl.object_offset;
207 dl.block_offset = do_div(tmp, dl.block_size);
209 snprintf(dl.object_name, sizeof(dl.object_name), "%llx.%08llx",
210 ceph_ino(inode), dl.object_no);
212 oloc.pool = ci->i_layout.pool_id;
213 oloc.pool_ns = ceph_try_get_string(ci->i_layout.pool_ns);
214 ceph_oid_printf(&oid, "%s", dl.object_name);
216 r = ceph_object_locator_to_pg(osdc->osdmap, &oid, &oloc, &pgid);
218 ceph_oloc_destroy(&oloc);
220 up_read(&osdc->lock);
224 dl.osd = ceph_pg_to_acting_primary(osdc->osdmap, &pgid);
226 struct ceph_entity_addr *a =
227 ceph_osd_addr(osdc->osdmap, dl.osd);
229 memcpy(&dl.osd_addr, &a->in_addr, sizeof(dl.osd_addr));
231 memset(&dl.osd_addr, 0, sizeof(dl.osd_addr));
233 up_read(&osdc->lock);
235 /* send result back to user */
236 if (copy_to_user(arg, &dl, sizeof(dl)))
242 static long ceph_ioctl_lazyio(struct file *file)
244 struct ceph_file_info *fi = file->private_data;
245 struct inode *inode = file_inode(file);
246 struct ceph_inode_info *ci = ceph_inode(inode);
247 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
249 if ((fi->fmode & CEPH_FILE_MODE_LAZY) == 0) {
250 spin_lock(&ci->i_ceph_lock);
251 fi->fmode |= CEPH_FILE_MODE_LAZY;
252 ci->i_nr_by_mode[ffs(CEPH_FILE_MODE_LAZY)]++;
253 __ceph_touch_fmode(ci, mdsc, fi->fmode);
254 spin_unlock(&ci->i_ceph_lock);
255 dout("ioctl_layzio: file %p marked lazy\n", file);
257 ceph_check_caps(ci, 0);
259 dout("ioctl_layzio: file %p already lazy\n", file);
264 static long ceph_ioctl_syncio(struct file *file)
266 struct ceph_file_info *fi = file->private_data;
268 fi->flags |= CEPH_F_SYNC;
272 static int vet_mds_for_fscrypt(struct file *file)
274 int i, ret = -EOPNOTSUPP;
275 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(file_inode(file)->i_sb);
277 mutex_lock(&mdsc->mutex);
278 for (i = 0; i < mdsc->max_sessions; i++) {
279 struct ceph_mds_session *s = mdsc->sessions[i];
283 if (test_bit(CEPHFS_FEATURE_ALTERNATE_NAME, &s->s_features))
287 mutex_unlock(&mdsc->mutex);
291 static long ceph_set_encryption_policy(struct file *file, unsigned long arg)
294 struct inode *inode = file_inode(file);
295 struct ceph_inode_info *ci = ceph_inode(inode);
297 ret = vet_mds_for_fscrypt(file);
302 * Ensure we hold these caps so that we _know_ that the rstats check
303 * in the empty_dir check is reliable.
305 ret = ceph_get_caps(file, CEPH_CAP_FILE_SHARED, 0, -1, &got);
309 ret = fscrypt_ioctl_set_policy(file, (const void __user *)arg);
311 ceph_put_cap_refs(ci, got);
316 static const char *ceph_ioctl_cmd_name(const unsigned int cmd)
319 case CEPH_IOC_GET_LAYOUT:
321 case CEPH_IOC_SET_LAYOUT:
323 case CEPH_IOC_SET_LAYOUT_POLICY:
324 return "set_layout_policy";
325 case CEPH_IOC_GET_DATALOC:
326 return "get_dataloc";
327 case CEPH_IOC_LAZYIO:
329 case CEPH_IOC_SYNCIO:
331 case FS_IOC_SET_ENCRYPTION_POLICY:
332 return "set_encryption_policy";
333 case FS_IOC_GET_ENCRYPTION_POLICY:
334 return "get_encryption_policy";
335 case FS_IOC_GET_ENCRYPTION_POLICY_EX:
336 return "get_encryption_policy_ex";
337 case FS_IOC_ADD_ENCRYPTION_KEY:
338 return "add_encryption_key";
339 case FS_IOC_REMOVE_ENCRYPTION_KEY:
340 return "remove_encryption_key";
341 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
342 return "remove_encryption_key_all_users";
343 case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
344 return "get_encryption_key_status";
345 case FS_IOC_GET_ENCRYPTION_NONCE:
346 return "get_encryption_nonce";
352 long ceph_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
356 dout("ioctl file %p cmd %s arg %lu\n", file,
357 ceph_ioctl_cmd_name(cmd), arg);
359 case CEPH_IOC_GET_LAYOUT:
360 return ceph_ioctl_get_layout(file, (void __user *)arg);
362 case CEPH_IOC_SET_LAYOUT:
363 return ceph_ioctl_set_layout(file, (void __user *)arg);
365 case CEPH_IOC_SET_LAYOUT_POLICY:
366 return ceph_ioctl_set_layout_policy(file, (void __user *)arg);
368 case CEPH_IOC_GET_DATALOC:
369 return ceph_ioctl_get_dataloc(file, (void __user *)arg);
371 case CEPH_IOC_LAZYIO:
372 return ceph_ioctl_lazyio(file);
374 case CEPH_IOC_SYNCIO:
375 return ceph_ioctl_syncio(file);
377 case FS_IOC_SET_ENCRYPTION_POLICY:
378 return ceph_set_encryption_policy(file, arg);
380 case FS_IOC_GET_ENCRYPTION_POLICY:
381 ret = vet_mds_for_fscrypt(file);
384 return fscrypt_ioctl_get_policy(file, (void __user *)arg);
386 case FS_IOC_GET_ENCRYPTION_POLICY_EX:
387 ret = vet_mds_for_fscrypt(file);
390 return fscrypt_ioctl_get_policy_ex(file, (void __user *)arg);
392 case FS_IOC_ADD_ENCRYPTION_KEY:
393 ret = vet_mds_for_fscrypt(file);
396 return fscrypt_ioctl_add_key(file, (void __user *)arg);
398 case FS_IOC_REMOVE_ENCRYPTION_KEY:
399 return fscrypt_ioctl_remove_key(file, (void __user *)arg);
401 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
402 return fscrypt_ioctl_remove_key_all_users(file,
405 case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
406 return fscrypt_ioctl_get_key_status(file, (void __user *)arg);
408 case FS_IOC_GET_ENCRYPTION_NONCE:
409 ret = vet_mds_for_fscrypt(file);
412 return fscrypt_ioctl_get_nonce(file, (void __user *)arg);