2 * Copyright (c) 2011-2015 The DragonFly Project. All rights reserved.
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>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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
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.
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
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.
45 static int hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data);
46 static int hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data);
47 static int hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data);
48 static int hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data);
49 static int hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data);
50 static int hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data);
51 static int hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data);
52 static int hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data);
53 static int hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data);
54 static int hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data);
55 static int hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data);
56 static int hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data);
57 static int hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data);
58 static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data);
59 static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data);
60 static int hammer2_ioctl_debug_dump(hammer2_inode_t *ip);
61 //static int hammer2_ioctl_inode_comp_set(hammer2_inode_t *ip, void *data);
62 //static int hammer2_ioctl_inode_comp_rec_set(hammer2_inode_t *ip, void *data);
63 //static int hammer2_ioctl_inode_comp_rec_set2(hammer2_inode_t *ip, void *data);
64 static int hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data);
67 hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
73 * Standard root cred checks, will be selectively ignored below
74 * for ioctls that do not require root creds.
76 error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
79 case HAMMER2IOC_VERSION_GET:
80 error = hammer2_ioctl_version_get(ip, data);
82 case HAMMER2IOC_RECLUSTER:
84 error = hammer2_ioctl_recluster(ip, data);
86 case HAMMER2IOC_REMOTE_SCAN:
88 error = hammer2_ioctl_remote_scan(ip, data);
90 case HAMMER2IOC_REMOTE_ADD:
92 error = hammer2_ioctl_remote_add(ip, data);
94 case HAMMER2IOC_REMOTE_DEL:
96 error = hammer2_ioctl_remote_del(ip, data);
98 case HAMMER2IOC_REMOTE_REP:
100 error = hammer2_ioctl_remote_rep(ip, data);
102 case HAMMER2IOC_SOCKET_GET:
104 error = hammer2_ioctl_socket_get(ip, data);
106 case HAMMER2IOC_SOCKET_SET:
108 error = hammer2_ioctl_socket_set(ip, data);
110 case HAMMER2IOC_PFS_GET:
112 error = hammer2_ioctl_pfs_get(ip, data);
114 case HAMMER2IOC_PFS_LOOKUP:
116 error = hammer2_ioctl_pfs_lookup(ip, data);
118 case HAMMER2IOC_PFS_CREATE:
120 error = hammer2_ioctl_pfs_create(ip, data);
122 case HAMMER2IOC_PFS_DELETE:
124 error = hammer2_ioctl_pfs_delete(ip, data);
126 case HAMMER2IOC_PFS_SNAPSHOT:
128 error = hammer2_ioctl_pfs_snapshot(ip, data);
130 case HAMMER2IOC_INODE_GET:
131 error = hammer2_ioctl_inode_get(ip, data);
133 case HAMMER2IOC_INODE_SET:
135 error = hammer2_ioctl_inode_set(ip, data);
137 case HAMMER2IOC_BULKFREE_SCAN:
138 error = hammer2_ioctl_bulkfree_scan(ip, data);
140 /*case HAMMER2IOC_INODE_COMP_SET:
141 error = hammer2_ioctl_inode_comp_set(ip, data);
143 case HAMMER2IOC_INODE_COMP_REC_SET:
144 error = hammer2_ioctl_inode_comp_rec_set(ip, data);
146 case HAMMER2IOC_INODE_COMP_REC_SET2:
147 error = hammer2_ioctl_inode_comp_rec_set2(ip, data);
149 case HAMMER2IOC_DEBUG_DUMP:
150 error = hammer2_ioctl_debug_dump(ip);
160 * Retrieve version and basic info
163 hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
165 hammer2_dev_t *hmp = ip->pmp->iroot->cluster.focus->hmp;
166 hammer2_ioc_version_t *version = data;
168 version->version = hmp->voldata.version;
173 hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
175 hammer2_ioc_recluster_t *recl = data;
177 hammer2_cluster_t *cluster;
180 fp = holdfp(curproc->p_fd, recl->fd, -1);
182 kprintf("reconnect to cluster: XXX ");
183 cluster = &ip->pmp->iroot->cluster;
184 if (cluster->nchains != 1 || cluster->focus == NULL) {
185 kprintf("not a local device mount\n");
188 hammer2_cluster_reconnect(cluster->focus->hmp, fp);
199 * Retrieve information about a remote
202 hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
204 hammer2_dev_t *hmp = ip->pmp->iroot->cluster.focus->hmp;
205 hammer2_ioc_remote_t *remote = data;
206 int copyid = remote->copyid;
208 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
211 hammer2_voldata_lock(hmp);
212 remote->copy1 = hmp->voldata.copyinfo[copyid];
213 hammer2_voldata_unlock(hmp);
216 * Adjust nextid (GET only)
218 while (++copyid < HAMMER2_COPYID_COUNT &&
219 hmp->voldata.copyinfo[copyid].copyid == 0) {
222 if (copyid == HAMMER2_COPYID_COUNT)
225 remote->nextid = copyid;
231 * Add new remote entry
234 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
236 hammer2_ioc_remote_t *remote = data;
237 hammer2_pfs_t *pmp = ip->pmp;
239 int copyid = remote->copyid;
242 if (copyid >= HAMMER2_COPYID_COUNT)
245 hmp = pmp->iroot->cluster.focus->hmp; /* XXX */
246 hammer2_voldata_lock(hmp);
248 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
249 if (hmp->voldata.copyinfo[copyid].copyid == 0)
252 if (copyid == HAMMER2_COPYID_COUNT) {
257 hammer2_voldata_modify(hmp);
258 remote->copy1.copyid = copyid;
259 hmp->voldata.copyinfo[copyid] = remote->copy1;
260 hammer2_volconf_update(hmp, copyid);
262 hammer2_voldata_unlock(hmp);
267 * Delete existing remote entry
270 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
272 hammer2_ioc_remote_t *remote = data;
273 hammer2_pfs_t *pmp = ip->pmp;
275 int copyid = remote->copyid;
278 hmp = pmp->iroot->cluster.focus->hmp; /* XXX */
279 if (copyid >= HAMMER2_COPYID_COUNT)
281 remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
282 hammer2_voldata_lock(hmp);
284 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
285 if (hmp->voldata.copyinfo[copyid].copyid == 0)
287 if (strcmp(remote->copy1.path,
288 hmp->voldata.copyinfo[copyid].path) == 0) {
292 if (copyid == HAMMER2_COPYID_COUNT) {
297 hammer2_voldata_modify(hmp);
298 hmp->voldata.copyinfo[copyid].copyid = 0;
299 hammer2_volconf_update(hmp, copyid);
301 hammer2_voldata_unlock(hmp);
306 * Replace existing remote entry
309 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
311 hammer2_ioc_remote_t *remote = data;
313 int copyid = remote->copyid;
315 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
317 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
320 hammer2_voldata_lock(hmp);
321 hammer2_voldata_modify(hmp);
322 /*hammer2_volconf_update(hmp, copyid);*/
323 hammer2_voldata_unlock(hmp);
329 * Retrieve communications socket
332 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
338 * Set communications socket for connection
341 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
343 hammer2_ioc_remote_t *remote = data;
345 int copyid = remote->copyid;
347 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
348 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
351 hammer2_voldata_lock(hmp);
352 hammer2_voldata_unlock(hmp);
358 * Used to scan and retrieve PFS information. PFS's are directories under
361 * To scan PFSs pass name_key=0. The function will scan for the next
362 * PFS and set all fields, as well as set name_next to the next key.
363 * When no PFSs remain, name_next is set to (hammer2_key_t)-1.
365 * To retrieve the PFS associated with the file descriptor, pass
366 * name_key set to (hammer2_key_t)-1.
369 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
371 const hammer2_inode_data_t *ripdata;
373 hammer2_ioc_pfs_t *pfs;
374 hammer2_cluster_t *cparent;
375 hammer2_cluster_t *rcluster;
376 hammer2_cluster_t *cluster;
377 hammer2_key_t key_next;
381 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
383 cparent = hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_ALWAYS);
384 rcluster = hammer2_inode_lock(ip->pmp->iroot, HAMMER2_RESOLVE_ALWAYS);
387 * Search for the first key or specific key. Remember that keys
388 * can be returned in any order.
390 if (pfs->name_key == 0) {
391 cluster = hammer2_cluster_lookup(cparent, &key_next,
392 0, (hammer2_key_t)-1,
394 } else if (pfs->name_key == (hammer2_key_t)-1) {
395 ripdata = &hammer2_cluster_rdata(rcluster)->ipdata;
396 cluster = hammer2_cluster_lookup(cparent, &key_next,
400 ripdata = NULL; /* safety */
402 cluster = hammer2_cluster_lookup(cparent, &key_next,
403 pfs->name_key, pfs->name_key,
406 hammer2_inode_unlock(ip->pmp->iroot, rcluster);
409 hammer2_cluster_type(cluster) != HAMMER2_BREF_TYPE_INODE) {
410 cluster = hammer2_cluster_next(cparent, cluster, &key_next,
411 key_next, (hammer2_key_t)-1,
416 * Load the data being returned by the ioctl.
418 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
419 pfs->name_key = ripdata->name_key;
420 pfs->pfs_type = ripdata->pfs_type;
421 pfs->pfs_subtype = ripdata->pfs_subtype;
422 pfs->pfs_clid = ripdata->pfs_clid;
423 pfs->pfs_fsid = ripdata->pfs_fsid;
424 KKASSERT(ripdata->name_len < sizeof(pfs->name));
425 bcopy(ripdata->filename, pfs->name, ripdata->name_len);
426 pfs->name[ripdata->name_len] = 0;
427 ripdata = NULL; /* safety */
430 * Calculate the next field
433 cluster = hammer2_cluster_next(cparent, cluster,
435 0, (hammer2_key_t)-1,
438 hammer2_cluster_type(cluster) !=
439 HAMMER2_BREF_TYPE_INODE);
441 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
442 pfs->name_next = ripdata->name_key;
443 hammer2_cluster_unlock(cluster);
444 hammer2_cluster_drop(cluster);
446 pfs->name_next = (hammer2_key_t)-1;
449 pfs->name_next = (hammer2_key_t)-1;
452 hammer2_inode_unlock(hmp->spmp->iroot, cparent);
458 * Find a specific PFS by name
461 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
463 const hammer2_inode_data_t *ripdata;
465 hammer2_ioc_pfs_t *pfs;
466 hammer2_cluster_t *cparent;
467 hammer2_cluster_t *cluster;
468 hammer2_key_t key_next;
474 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
476 cparent = hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_ALWAYS |
477 HAMMER2_RESOLVE_SHARED);
479 pfs->name[sizeof(pfs->name) - 1] = 0;
480 len = strlen(pfs->name);
481 lhc = hammer2_dirhash(pfs->name, len);
483 cluster = hammer2_cluster_lookup(cparent, &key_next,
484 lhc, lhc + HAMMER2_DIRHASH_LOMASK,
485 HAMMER2_LOOKUP_SHARED);
487 if (hammer2_cluster_type(cluster) == HAMMER2_BREF_TYPE_INODE) {
488 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
489 if (ripdata->name_len == len &&
490 bcmp(ripdata->filename, pfs->name, len) == 0) {
493 ripdata = NULL; /* safety */
495 cluster = hammer2_cluster_next(cparent, cluster, &key_next,
497 lhc + HAMMER2_DIRHASH_LOMASK,
498 HAMMER2_LOOKUP_SHARED);
502 * Load the data being returned by the ioctl.
505 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
506 pfs->name_key = ripdata->name_key;
507 pfs->pfs_type = ripdata->pfs_type;
508 pfs->pfs_subtype = ripdata->pfs_subtype;
509 pfs->pfs_clid = ripdata->pfs_clid;
510 pfs->pfs_fsid = ripdata->pfs_fsid;
513 hammer2_cluster_unlock(cluster);
514 hammer2_cluster_drop(cluster);
518 hammer2_inode_unlock(hmp->spmp->iroot, cparent);
524 * Create a new PFS under the super-root
527 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
529 hammer2_inode_data_t *nipdata;
531 hammer2_ioc_pfs_t *pfs;
532 hammer2_inode_t *nip;
533 hammer2_cluster_t *ncluster;
534 hammer2_trans_t trans;
535 hammer2_blockref_t bref;
538 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
542 if (pfs->name[0] == 0)
544 pfs->name[sizeof(pfs->name) - 1] = 0; /* ensure 0-termination */
546 if (hammer2_ioctl_pfs_lookup(ip, pfs) == 0)
549 hammer2_trans_init(&trans, hmp->spmp, HAMMER2_TRANS_NEWINODE);
550 nip = hammer2_inode_create(&trans, hmp->spmp->iroot, NULL, NULL,
551 pfs->name, strlen(pfs->name),
553 HAMMER2_INSERT_PFSROOT, &error);
555 nipdata = hammer2_cluster_modify_ip(&trans, nip, ncluster, 0);
556 nipdata->pfs_type = pfs->pfs_type;
557 nipdata->pfs_subtype = pfs->pfs_subtype;
558 nipdata->pfs_clid = pfs->pfs_clid;
559 nipdata->pfs_fsid = pfs->pfs_fsid;
560 nipdata->op_flags |= HAMMER2_OPFLAG_PFSROOT;
563 * Do not allow compression on PFS's with the special name
564 * "boot", the boot loader can't decompress (yet).
566 if (strcmp(pfs->name, "boot") == 0)
567 nipdata->comp_algo = HAMMER2_ENC_ALGO(
568 HAMMER2_COMP_AUTOZERO);
569 hammer2_cluster_modsync(ncluster);
570 hammer2_cluster_bref(ncluster, &bref);
572 kprintf("ADD LOCAL PFS (IOCTL): %s\n", nipdata->filename);
573 hammer2_pfsalloc(ncluster, nipdata, bref.modify_tid);
576 hammer2_inode_unlock(nip, ncluster);
578 hammer2_trans_done(&trans);
584 * Destroy an existing PFS under the super-root
587 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
590 hammer2_ioc_pfs_t *pfs = data;
591 hammer2_trans_t trans;
594 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
595 hammer2_trans_init(&trans, hmp->spmp, 0);
596 error = hammer2_unlink_file(&trans, hmp->spmp->iroot,
597 pfs->name, strlen(pfs->name),
599 hammer2_trans_done(&trans);
605 hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
607 hammer2_ioc_pfs_t *pfs = data;
608 hammer2_trans_t trans;
609 hammer2_cluster_t *cparent;
612 if (pfs->name[0] == 0)
614 if (pfs->name[sizeof(pfs->name)-1] != 0)
617 hammer2_vfs_sync(ip->pmp->mp, MNT_WAIT);
619 hammer2_trans_init(&trans, ip->pmp,
620 HAMMER2_TRANS_ISFLUSH | HAMMER2_TRANS_NEWINODE);
621 cparent = hammer2_inode_lock(ip, HAMMER2_RESOLVE_ALWAYS);
622 error = hammer2_cluster_snapshot(&trans, cparent, pfs);
623 hammer2_inode_unlock(ip, cparent);
624 hammer2_trans_done(&trans);
630 * Retrieve the raw inode structure
633 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
635 const hammer2_inode_data_t *ripdata;
636 hammer2_ioc_inode_t *ino;
637 hammer2_cluster_t *cparent;
642 cparent = hammer2_inode_lock(ip, HAMMER2_RESOLVE_ALWAYS |
643 HAMMER2_RESOLVE_SHARED);
644 if (cparent->error) {
647 ripdata = &hammer2_cluster_rdata(cparent)->ipdata;
648 ino->ip_data = *ripdata;
652 hammer2_inode_unlock(ip, cparent);
658 * Set various parameters in an inode which cannot be set through
659 * normal filesystem VNOPS.
662 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
664 const hammer2_inode_data_t *ripdata;
665 hammer2_inode_data_t *wipdata;
666 hammer2_ioc_inode_t *ino = data;
667 hammer2_cluster_t *cparent;
668 hammer2_trans_t trans;
672 hammer2_trans_init(&trans, ip->pmp, 0);
673 cparent = hammer2_inode_lock(ip, HAMMER2_RESOLVE_ALWAYS);
674 ripdata = &hammer2_cluster_rdata(cparent)->ipdata;
676 if (ino->ip_data.check_algo != ripdata->check_algo) {
677 wipdata = hammer2_cluster_modify_ip(&trans, ip, cparent, 0);
678 wipdata->check_algo = ino->ip_data.check_algo;
679 ripdata = wipdata; /* safety */
680 hammer2_cluster_setmethod_check(&trans, cparent,
681 wipdata->check_algo);
684 if (ino->ip_data.comp_algo != ripdata->comp_algo) {
685 wipdata = hammer2_cluster_modify_ip(&trans, ip, cparent, 0);
686 wipdata->comp_algo = ino->ip_data.comp_algo;
687 ripdata = wipdata; /* safety */
692 /* Ignore these flags for now...*/
693 if (ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) {
695 if (ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) {
697 if (ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) {
700 hammer2_cluster_modsync(cparent);
701 hammer2_trans_done(&trans);
702 hammer2_inode_unlock(ip, cparent);
709 hammer2_ioctl_debug_dump(hammer2_inode_t *ip)
711 hammer2_chain_t *chain;
715 for (i = 0; i < ip->cluster.nchains; ++i) {
716 chain = ip->cluster.array[i].chain;
719 hammer2_dump_chain(chain, 0, &count, 'i');
726 hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data)
728 hammer2_ioc_bulkfree_t *bfi = data;
729 hammer2_dev_t *hmp = ip->pmp->iroot->cluster.focus->hmp;
732 /* XXX run local cluster targets only */
733 error = hammer2_bulkfree_pass(hmp, bfi);