hammer2 - cluster API, preliminary implementation of multi-chain updates
[dragonfly.git] / sys / vfs / hammer2 / hammer2_ioctl.c
CommitLineData
2910a90c 1/*
8138a154 2 * Copyright (c) 2011-2014 The DragonFly Project. All rights reserved.
2910a90c
MD
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@dragonflybsd.org>
6 * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 * 3. Neither the name of The DragonFly Project nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific, prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35/*
36 * Ioctl Functions.
37 *
38 * WARNING! The ioctl functions which manipulate the connection state need
39 * to be able to run without deadlock on the volume's chain lock.
40 * Most of these functions use a separate lock.
41 */
42
43#include "hammer2.h"
44
ae183399 45static int hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data);
1a34728c
MD
46static int hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data);
47static int hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data);
ae183399
MD
48static int hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data);
49static int hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data);
50static int hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data);
51static int hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data);
52static int hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data);
53static int hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data);
458ecb1b 54static int hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data);
ae183399 55static int hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data);
a864c5d9 56static int hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data);
ae183399 57static int hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data);
344d4f82
MD
58static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data);
59static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data);
355d67fc
MD
60//static int hammer2_ioctl_inode_comp_set(hammer2_inode_t *ip, void *data);
61//static int hammer2_ioctl_inode_comp_rec_set(hammer2_inode_t *ip, void *data);
62//static int hammer2_ioctl_inode_comp_rec_set2(hammer2_inode_t *ip, void *data);
2910a90c
MD
63
64int
65hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
66 struct ucred *cred)
67{
68 int error;
69
70 /*
71 * Standard root cred checks, will be selectively ignored below
72 * for ioctls that do not require root creds.
73 */
74 error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
75
76 switch(com) {
ae183399
MD
77 case HAMMER2IOC_VERSION_GET:
78 error = hammer2_ioctl_version_get(ip, data);
2910a90c 79 break;
1a34728c 80 case HAMMER2IOC_RECLUSTER:
2910a90c 81 if (error == 0)
1a34728c
MD
82 error = hammer2_ioctl_recluster(ip, data);
83 break;
84 case HAMMER2IOC_REMOTE_SCAN:
85 if (error == 0)
86 error = hammer2_ioctl_remote_scan(ip, data);
2910a90c 87 break;
ae183399 88 case HAMMER2IOC_REMOTE_ADD:
2910a90c 89 if (error == 0)
ae183399 90 error = hammer2_ioctl_remote_add(ip, data);
2910a90c 91 break;
ae183399 92 case HAMMER2IOC_REMOTE_DEL:
2910a90c 93 if (error == 0)
ae183399 94 error = hammer2_ioctl_remote_del(ip, data);
2910a90c 95 break;
ae183399 96 case HAMMER2IOC_REMOTE_REP:
2910a90c 97 if (error == 0)
ae183399 98 error = hammer2_ioctl_remote_rep(ip, data);
2910a90c 99 break;
ae183399 100 case HAMMER2IOC_SOCKET_GET:
2910a90c 101 if (error == 0)
ae183399 102 error = hammer2_ioctl_socket_get(ip, data);
2910a90c 103 break;
ae183399
MD
104 case HAMMER2IOC_SOCKET_SET:
105 if (error == 0)
106 error = hammer2_ioctl_socket_set(ip, data);
107 break;
108 case HAMMER2IOC_PFS_GET:
2910a90c 109 if (error == 0)
ae183399
MD
110 error = hammer2_ioctl_pfs_get(ip, data);
111 break;
458ecb1b
MD
112 case HAMMER2IOC_PFS_LOOKUP:
113 if (error == 0)
114 error = hammer2_ioctl_pfs_lookup(ip, data);
115 break;
ae183399
MD
116 case HAMMER2IOC_PFS_CREATE:
117 if (error == 0)
118 error = hammer2_ioctl_pfs_create(ip, data);
119 break;
120 case HAMMER2IOC_PFS_DELETE:
121 if (error == 0)
122 error = hammer2_ioctl_pfs_delete(ip, data);
2910a90c 123 break;
a864c5d9
MD
124 case HAMMER2IOC_PFS_SNAPSHOT:
125 if (error == 0)
126 error = hammer2_ioctl_pfs_snapshot(ip, data);
127 break;
344d4f82
MD
128 case HAMMER2IOC_INODE_GET:
129 error = hammer2_ioctl_inode_get(ip, data);
130 break;
131 case HAMMER2IOC_INODE_SET:
132 if (error == 0)
133 error = hammer2_ioctl_inode_set(ip, data);
134 break;
355d67fc
MD
135 /*case HAMMER2IOC_INODE_COMP_SET:
136 error = hammer2_ioctl_inode_comp_set(ip, data);
137 break;
138 case HAMMER2IOC_INODE_COMP_REC_SET:
139 error = hammer2_ioctl_inode_comp_rec_set(ip, data);
140 break;
141 case HAMMER2IOC_INODE_COMP_REC_SET2:
142 error = hammer2_ioctl_inode_comp_rec_set2(ip, data);
143 break;*/
2910a90c
MD
144 default:
145 error = EOPNOTSUPP;
146 break;
147 }
148 return (error);
149}
150
151/*
152 * Retrieve version and basic info
153 */
154static int
ae183399 155hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
2910a90c 156{
278ab2b2 157 hammer2_mount_t *hmp = ip->pmp->cluster.focus->hmp;
2910a90c
MD
158 hammer2_ioc_version_t *version = data;
159
160 version->version = hmp->voldata.version;
161 return 0;
162}
163
1a34728c
MD
164static int
165hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
166{
167 hammer2_ioc_recluster_t *recl = data;
168 struct file *fp;
169
170 fp = holdfp(curproc->p_fd, recl->fd, -1);
171 if (fp) {
172 kprintf("reconnect to cluster\n");
173 hammer2_cluster_reconnect(ip->pmp, fp);
174 return 0;
175 } else {
176 return EINVAL;
177 }
178}
179
2910a90c
MD
180/*
181 * Retrieve information about a remote
182 */
183static int
1a34728c 184hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
2910a90c 185{
278ab2b2 186 hammer2_mount_t *hmp = ip->pmp->cluster.focus->hmp;
2910a90c
MD
187 hammer2_ioc_remote_t *remote = data;
188 int copyid = remote->copyid;
189
190 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
191 return (EINVAL);
192
193 hammer2_voldata_lock(hmp);
194 remote->copy1 = hmp->voldata.copyinfo[copyid];
0dea3156 195 hammer2_voldata_unlock(hmp, 0);
2910a90c
MD
196
197 /*
198 * Adjust nextid (GET only)
199 */
200 while (++copyid < HAMMER2_COPYID_COUNT &&
201 hmp->voldata.copyinfo[copyid].copyid == 0) {
1a34728c 202 ;
2910a90c
MD
203 }
204 if (copyid == HAMMER2_COPYID_COUNT)
205 remote->nextid = -1;
206 else
207 remote->nextid = copyid;
208
209 return(0);
210}
211
212/*
213 * Add new remote entry
214 */
215static int
ae183399 216hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
2910a90c 217{
2910a90c 218 hammer2_ioc_remote_t *remote = data;
a5913bdf
MD
219 hammer2_pfsmount_t *pmp = ip->pmp;
220 hammer2_mount_t *hmp;
2910a90c
MD
221 int copyid = remote->copyid;
222 int error = 0;
223
224 if (copyid >= HAMMER2_COPYID_COUNT)
225 return (EINVAL);
226
278ab2b2 227 hmp = pmp->cluster.focus->hmp; /* XXX */
2910a90c
MD
228 hammer2_voldata_lock(hmp);
229 if (copyid < 0) {
230 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
231 if (hmp->voldata.copyinfo[copyid].copyid == 0)
232 break;
233 }
234 if (copyid == HAMMER2_COPYID_COUNT) {
235 error = ENOSPC;
236 goto failed;
237 }
238 }
239 hammer2_modify_volume(hmp);
2910a90c
MD
240 remote->copy1.copyid = copyid;
241 hmp->voldata.copyinfo[copyid] = remote->copy1;
1a34728c 242 hammer2_volconf_update(pmp, copyid);
2910a90c 243failed:
0dea3156 244 hammer2_voldata_unlock(hmp, 1);
2910a90c
MD
245 return (error);
246}
247
248/*
249 * Delete existing remote entry
250 */
251static int
ae183399 252hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
2910a90c 253{
2910a90c 254 hammer2_ioc_remote_t *remote = data;
a5913bdf
MD
255 hammer2_pfsmount_t *pmp = ip->pmp;
256 hammer2_mount_t *hmp;
2910a90c
MD
257 int copyid = remote->copyid;
258 int error = 0;
259
278ab2b2 260 hmp = pmp->cluster.focus->hmp; /* XXX */
2910a90c
MD
261 if (copyid >= HAMMER2_COPYID_COUNT)
262 return (EINVAL);
263 remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
264 hammer2_voldata_lock(hmp);
265 if (copyid < 0) {
266 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
267 if (hmp->voldata.copyinfo[copyid].copyid == 0)
268 continue;
269 if (strcmp(remote->copy1.path,
270 hmp->voldata.copyinfo[copyid].path) == 0) {
271 break;
272 }
273 }
274 if (copyid == HAMMER2_COPYID_COUNT) {
275 error = ENOENT;
276 goto failed;
277 }
278 }
279 hammer2_modify_volume(hmp);
280 hmp->voldata.copyinfo[copyid].copyid = 0;
1a34728c 281 hammer2_volconf_update(pmp, copyid);
2910a90c 282failed:
0dea3156 283 hammer2_voldata_unlock(hmp, 1);
2910a90c
MD
284 return (error);
285}
286
287/*
288 * Replace existing remote entry
289 */
290static int
ae183399 291hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
2910a90c 292{
2910a90c 293 hammer2_ioc_remote_t *remote = data;
a5913bdf 294 hammer2_mount_t *hmp;
2910a90c
MD
295 int copyid = remote->copyid;
296
278ab2b2 297 hmp = ip->pmp->cluster.focus->hmp; /* XXX */
a5913bdf 298
2910a90c
MD
299 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
300 return (EINVAL);
301
302 hammer2_voldata_lock(hmp);
1a34728c 303 /*hammer2_volconf_update(pmp, copyid);*/
0dea3156 304 hammer2_voldata_unlock(hmp, 1);
2910a90c
MD
305
306 return(0);
307}
308
309/*
310 * Retrieve communications socket
311 */
312static int
ae183399 313hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
2910a90c
MD
314{
315 return (EOPNOTSUPP);
316}
317
318/*
319 * Set communications socket for connection
320 */
321static int
ae183399 322hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
2910a90c 323{
2910a90c 324 hammer2_ioc_remote_t *remote = data;
a5913bdf 325 hammer2_mount_t *hmp;
2910a90c
MD
326 int copyid = remote->copyid;
327
278ab2b2 328 hmp = ip->pmp->cluster.focus->hmp; /* XXX */
2910a90c
MD
329 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
330 return (EINVAL);
331
332 hammer2_voldata_lock(hmp);
0dea3156 333 hammer2_voldata_unlock(hmp, 0);
2910a90c
MD
334
335 return(0);
336}
ae183399
MD
337
338/*
a864c5d9
MD
339 * Used to scan and retrieve PFS information. PFS's are directories under
340 * the super-root.
341 *
342 * To scan PFSs pass name_key=0. The function will scan for the next
343 * PFS and set all fields, as well as set name_next to the next key.
344 * When no PFSs remain, name_next is set to (hammer2_key_t)-1.
345 *
346 * To retrieve the PFS associated with the file descriptor, pass
347 * name_key set to (hammer2_key_t)-1.
ae183399
MD
348 */
349static int
350hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
351{
6a5f4fe6 352 const hammer2_inode_data_t *ipdata;
476d2aad
MD
353 hammer2_mount_t *hmp;
354 hammer2_ioc_pfs_t *pfs;
278ab2b2
MD
355 hammer2_cluster_t *cparent;
356 hammer2_cluster_t *rcluster;
357 hammer2_cluster_t *cluster;
1897c66e 358 hammer2_key_t key_next;
476d2aad 359 int error;
278ab2b2 360 int ddflag;
ae183399 361
476d2aad 362 error = 0;
278ab2b2 363 hmp = ip->pmp->cluster.focus->hmp; /* XXX */
476d2aad 364 pfs = data;
278ab2b2
MD
365 cparent = hammer2_inode_lock_ex(hmp->sroot);
366 rcluster = hammer2_inode_lock_ex(ip->pmp->iroot);
ae183399
MD
367
368 /*
369 * Search for the first key or specific key. Remember that keys
370 * can be returned in any order.
371 */
372 if (pfs->name_key == 0) {
278ab2b2
MD
373 cluster = hammer2_cluster_lookup(cparent, &key_next,
374 0, (hammer2_key_t)-1,
375 0, &ddflag);
a864c5d9 376 } else if (pfs->name_key == (hammer2_key_t)-1) {
278ab2b2
MD
377 ipdata = &hammer2_cluster_data(rcluster)->ipdata;
378 cluster = hammer2_cluster_lookup(cparent, &key_next,
379 ipdata->name_key,
380 ipdata->name_key,
381 0, &ddflag);
382 ipdata = NULL; /* safety */
ae183399 383 } else {
278ab2b2
MD
384 cluster = hammer2_cluster_lookup(cparent, &key_next,
385 pfs->name_key, pfs->name_key,
386 0, &ddflag);
ae183399 387 }
278ab2b2 388 hammer2_inode_unlock_ex(ip->pmp->iroot, rcluster);
9b6b3df4 389
278ab2b2
MD
390 while (cluster &&
391 hammer2_cluster_type(cluster) != HAMMER2_BREF_TYPE_INODE) {
392 cluster = hammer2_cluster_next(cparent, cluster, &key_next,
393 key_next, (hammer2_key_t)-1,
394 0);
ae183399 395 }
278ab2b2 396 if (cluster) {
ae183399
MD
397 /*
398 * Load the data being returned by the ioctl.
399 */
278ab2b2 400 ipdata = &hammer2_cluster_data(cluster)->ipdata;
476d2aad
MD
401 pfs->name_key = ipdata->name_key;
402 pfs->pfs_type = ipdata->pfs_type;
403 pfs->pfs_clid = ipdata->pfs_clid;
404 pfs->pfs_fsid = ipdata->pfs_fsid;
405 KKASSERT(ipdata->name_len < sizeof(pfs->name));
406 bcopy(ipdata->filename, pfs->name, ipdata->name_len);
407 pfs->name[ipdata->name_len] = 0;
408 ipdata = NULL; /* safety */
ae183399
MD
409
410 /*
411 * Calculate the next field
412 */
413 do {
278ab2b2
MD
414 cluster = hammer2_cluster_next(cparent, cluster,
415 &key_next,
416 0, (hammer2_key_t)-1,
417 0);
418 } while (cluster &&
419 hammer2_cluster_type(cluster) !=
420 HAMMER2_BREF_TYPE_INODE);
421 if (cluster) {
422 ipdata = &hammer2_cluster_data(cluster)->ipdata;
423 pfs->name_next = ipdata->name_key;
424 hammer2_cluster_unlock(cluster);
ae183399
MD
425 } else {
426 pfs->name_next = (hammer2_key_t)-1;
427 }
428 } else {
429 pfs->name_next = (hammer2_key_t)-1;
430 error = ENOENT;
431 }
278ab2b2 432 hammer2_inode_unlock_ex(hmp->sroot, cparent);
0dea3156 433
ae183399
MD
434 return (error);
435}
436
458ecb1b
MD
437/*
438 * Find a specific PFS by name
439 */
440static int
441hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
442{
6a5f4fe6 443 const hammer2_inode_data_t *ipdata;
476d2aad
MD
444 hammer2_mount_t *hmp;
445 hammer2_ioc_pfs_t *pfs;
278ab2b2
MD
446 hammer2_cluster_t *cparent;
447 hammer2_cluster_t *cluster;
1897c66e 448 hammer2_key_t key_next;
458ecb1b 449 hammer2_key_t lhc;
476d2aad 450 int error;
278ab2b2 451 int ddflag;
458ecb1b
MD
452 size_t len;
453
476d2aad 454 error = 0;
278ab2b2 455 hmp = ip->pmp->cluster.focus->hmp; /* XXX */
476d2aad 456 pfs = data;
278ab2b2 457 cparent = hammer2_inode_lock_sh(hmp->sroot);
458ecb1b
MD
458
459 pfs->name[sizeof(pfs->name) - 1] = 0;
460 len = strlen(pfs->name);
461 lhc = hammer2_dirhash(pfs->name, len);
462
278ab2b2
MD
463 cluster = hammer2_cluster_lookup(cparent, &key_next,
464 lhc, lhc + HAMMER2_DIRHASH_LOMASK,
465 HAMMER2_LOOKUP_SHARED, &ddflag);
466 while (cluster) {
467 if (hammer2_cluster_type(cluster) == HAMMER2_BREF_TYPE_INODE) {
468 ipdata = &hammer2_cluster_data(cluster)->ipdata;
469 if (ipdata->name_len == len &&
470 bcmp(ipdata->filename, pfs->name, len) == 0) {
471 break;
472 }
473 ipdata = NULL; /* safety */
458ecb1b 474 }
278ab2b2 475 cluster = hammer2_cluster_next(cparent, cluster, &key_next,
1897c66e
MD
476 key_next,
477 lhc + HAMMER2_DIRHASH_LOMASK,
278ab2b2 478 HAMMER2_LOOKUP_SHARED);
458ecb1b
MD
479 }
480
481 /*
482 * Load the data being returned by the ioctl.
483 */
278ab2b2
MD
484 if (cluster) {
485 ipdata = &hammer2_cluster_data(cluster)->ipdata;
476d2aad
MD
486 pfs->name_key = ipdata->name_key;
487 pfs->pfs_type = ipdata->pfs_type;
488 pfs->pfs_clid = ipdata->pfs_clid;
489 pfs->pfs_fsid = ipdata->pfs_fsid;
490 ipdata = NULL;
458ecb1b 491
278ab2b2 492 hammer2_cluster_unlock(cluster);
458ecb1b
MD
493 } else {
494 error = ENOENT;
495 }
278ab2b2 496 hammer2_inode_unlock_sh(hmp->sroot, cparent);
7bed8d7e 497
458ecb1b
MD
498 return (error);
499}
500
ae183399
MD
501/*
502 * Create a new PFS under the super-root
503 */
504static int
505hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
506{
476d2aad
MD
507 hammer2_inode_data_t *nipdata;
508 hammer2_mount_t *hmp;
509 hammer2_ioc_pfs_t *pfs;
510 hammer2_inode_t *nip;
278ab2b2 511 hammer2_cluster_t *ncluster;
0dea3156 512 hammer2_trans_t trans;
ae183399
MD
513 int error;
514
278ab2b2 515 hmp = ip->pmp->cluster.focus->hmp; /* XXX */
476d2aad
MD
516 pfs = data;
517 nip = NULL;
518
a864c5d9
MD
519 if (pfs->name[0] == 0)
520 return(EINVAL);
ae183399 521 pfs->name[sizeof(pfs->name) - 1] = 0; /* ensure 0-termination */
10252dc7 522
10136ab6 523 hammer2_trans_init(&trans, ip->pmp, NULL, HAMMER2_TRANS_NEWINODE);
0dea3156 524 nip = hammer2_inode_create(&trans, hmp->sroot, NULL, NULL,
ae183399 525 pfs->name, strlen(pfs->name),
278ab2b2 526 &ncluster, &error);
ae183399 527 if (error == 0) {
278ab2b2 528 nipdata = hammer2_cluster_modify_ip(&trans, nip, ncluster,
4a59bd3e 529 HAMMER2_MODIFY_ASSERTNOCOPY);
476d2aad
MD
530 nipdata->pfs_type = pfs->pfs_type;
531 nipdata->pfs_clid = pfs->pfs_clid;
532 nipdata->pfs_fsid = pfs->pfs_fsid;
cdfd0a3e
MD
533
534 /*
535 * Do not allow compression on PFS's with the special name
536 * "boot", the boot loader can't decompress (yet).
537 */
538 if (strcmp(pfs->name, "boot") == 0)
539 nipdata->comp_algo = HAMMER2_COMP_AUTOZERO;
6a5f4fe6 540 hammer2_cluster_modsync(ncluster);
278ab2b2 541 hammer2_inode_unlock_ex(nip, ncluster);
ae183399 542 }
0dea3156 543 hammer2_trans_done(&trans);
278ab2b2 544
ae183399
MD
545 return (error);
546}
547
548/*
549 * Destroy an existing PFS under the super-root
550 */
551static int
552hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
553{
a5913bdf 554 hammer2_mount_t *hmp;
ae183399 555 hammer2_ioc_pfs_t *pfs = data;
0dea3156 556 hammer2_trans_t trans;
ae183399
MD
557 int error;
558
278ab2b2 559 hmp = ip->pmp->cluster.focus->hmp; /* XXX */
10136ab6 560 hammer2_trans_init(&trans, ip->pmp, NULL, 0);
0dea3156 561 error = hammer2_unlink_file(&trans, hmp->sroot,
9797e933 562 pfs->name, strlen(pfs->name),
044541cd 563 2, NULL, NULL);
a864c5d9
MD
564 hammer2_trans_done(&trans);
565
566 return (error);
567}
568
569static int
570hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
571{
a864c5d9
MD
572 hammer2_ioc_pfs_t *pfs = data;
573 hammer2_trans_t trans;
278ab2b2 574 hammer2_cluster_t *cparent;
a864c5d9
MD
575 int error;
576
577 if (pfs->name[0] == 0)
578 return(EINVAL);
579 if (pfs->name[sizeof(pfs->name)-1] != 0)
580 return(EINVAL);
581
a7720be7
MD
582 hammer2_vfs_sync(ip->pmp->mp, MNT_WAIT);
583
10136ab6 584 hammer2_trans_init(&trans, ip->pmp, NULL, HAMMER2_TRANS_NEWINODE);
278ab2b2
MD
585 cparent = hammer2_inode_lock_ex(ip);
586 error = hammer2_cluster_snapshot(&trans, cparent, pfs);
587 hammer2_inode_unlock_ex(ip, cparent);
0dea3156
MD
588 hammer2_trans_done(&trans);
589
ae183399
MD
590 return (error);
591}
344d4f82
MD
592
593/*
594 * Retrieve the raw inode structure
595 */
596static int
597hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
598{
6a5f4fe6
MD
599 const hammer2_inode_data_t *ipdata;
600 hammer2_ioc_inode_t *ino;
278ab2b2 601 hammer2_cluster_t *cparent;
344d4f82 602
6a5f4fe6
MD
603 ino = data;
604
278ab2b2
MD
605 cparent = hammer2_inode_lock_sh(ip);
606 ipdata = &hammer2_cluster_data(cparent)->ipdata;
607 ino->ip_data = *ipdata;
26b047fa 608 ino->kdata = ip;
278ab2b2 609 hammer2_inode_unlock_sh(ip, cparent);
0dea3156 610
344d4f82
MD
611 return (0);
612}
613
f481450f
MD
614/*
615 * Set various parameters in an inode which cannot be set through
616 * normal filesystem VNOPS.
617 */
344d4f82
MD
618static int
619hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
620{
6a5f4fe6
MD
621 const hammer2_inode_data_t *ripdata;
622 hammer2_inode_data_t *wipdata;
344d4f82 623 hammer2_ioc_inode_t *ino = data;
278ab2b2 624 hammer2_cluster_t *cparent;
355d67fc 625 hammer2_trans_t trans;
f481450f 626 int error = 0;
6a5f4fe6 627 int dosync = 0;
344d4f82 628
10136ab6 629 hammer2_trans_init(&trans, ip->pmp, NULL, 0);
278ab2b2 630 cparent = hammer2_inode_lock_ex(ip);
6a5f4fe6 631 ripdata = &hammer2_cluster_data(cparent)->ipdata;
f481450f 632
6a5f4fe6
MD
633 if (ino->ip_data.comp_algo != ripdata->comp_algo) {
634 wipdata = hammer2_cluster_modify_ip(&trans, ip, cparent, 0);
635 wipdata->comp_algo = ino->ip_data.comp_algo;
636 ripdata = wipdata; /* safety */
637 dosync = 1;
f481450f 638 }
355d67fc
MD
639 ino->kdata = ip;
640
f481450f 641 /* Ignore these flags for now...*/
344d4f82
MD
642 if (ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) {
643 }
644 if (ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) {
645 }
646 if (ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) {
647 }
6a5f4fe6
MD
648 if (dosync)
649 hammer2_cluster_modsync(cparent);
355d67fc 650 hammer2_trans_done(&trans);
278ab2b2 651 hammer2_inode_unlock_ex(ip, cparent);
0dea3156 652
344d4f82
MD
653 return (error);
654}