2 * Copyright (c) 2008 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * $DragonFly: src/sys/vfs/hammer/hammer_ioctl.c,v 1.32 2008/11/13 02:23:29 dillon Exp $
39 static int hammer_ioc_gethistory(hammer_transaction_t trans, hammer_inode_t ip,
40 struct hammer_ioc_history *hist);
41 static int hammer_ioc_synctid(hammer_transaction_t trans, hammer_inode_t ip,
42 struct hammer_ioc_synctid *std);
43 static int hammer_ioc_get_version(hammer_transaction_t trans,
45 struct hammer_ioc_version *ver);
46 static int hammer_ioc_set_version(hammer_transaction_t trans,
48 struct hammer_ioc_version *ver);
51 hammer_ioctl(hammer_inode_t ip, u_long com, caddr_t data, int fflag,
54 struct hammer_transaction trans;
57 error = priv_check_cred(cred, PRIV_ROOT, PRISON_ROOT);
59 hammer_start_transaction(&trans, ip->hmp);
64 error = hammer_ioc_prune(&trans, ip,
65 (struct hammer_ioc_prune *)data);
68 case HAMMERIOC_GETHISTORY:
69 error = hammer_ioc_gethistory(&trans, ip,
70 (struct hammer_ioc_history *)data);
72 case HAMMERIOC_REBLOCK:
74 error = hammer_ioc_reblock(&trans, ip,
75 (struct hammer_ioc_reblock *)data);
78 case HAMMERIOC_REBALANCE:
80 error = hammer_ioc_rebalance(&trans, ip,
81 (struct hammer_ioc_rebalance *)data);
84 case HAMMERIOC_SYNCTID:
85 error = hammer_ioc_synctid(&trans, ip,
86 (struct hammer_ioc_synctid *)data);
88 case HAMMERIOC_GET_PSEUDOFS:
89 error = hammer_ioc_get_pseudofs(&trans, ip,
90 (struct hammer_ioc_pseudofs_rw *)data);
92 case HAMMERIOC_SET_PSEUDOFS:
94 error = hammer_ioc_set_pseudofs(&trans, ip, cred,
95 (struct hammer_ioc_pseudofs_rw *)data);
98 case HAMMERIOC_UPG_PSEUDOFS:
100 error = hammer_ioc_upgrade_pseudofs(&trans, ip,
101 (struct hammer_ioc_pseudofs_rw *)data);
104 case HAMMERIOC_DGD_PSEUDOFS:
106 error = hammer_ioc_downgrade_pseudofs(&trans, ip,
107 (struct hammer_ioc_pseudofs_rw *)data);
110 case HAMMERIOC_RMR_PSEUDOFS:
112 error = hammer_ioc_destroy_pseudofs(&trans, ip,
113 (struct hammer_ioc_pseudofs_rw *)data);
116 case HAMMERIOC_WAI_PSEUDOFS:
118 error = hammer_ioc_wait_pseudofs(&trans, ip,
119 (struct hammer_ioc_pseudofs_rw *)data);
122 case HAMMERIOC_MIRROR_READ:
124 error = hammer_ioc_mirror_read(&trans, ip,
125 (struct hammer_ioc_mirror_rw *)data);
128 case HAMMERIOC_MIRROR_WRITE:
130 error = hammer_ioc_mirror_write(&trans, ip,
131 (struct hammer_ioc_mirror_rw *)data);
134 case HAMMERIOC_GET_VERSION:
135 error = hammer_ioc_get_version(&trans, ip,
136 (struct hammer_ioc_version *)data);
138 case HAMMERIOC_SET_VERSION:
140 error = hammer_ioc_set_version(&trans, ip,
141 (struct hammer_ioc_version *)data);
148 hammer_done_transaction(&trans);
153 * Iterate through an object's inode or an object's records and record
156 static void add_history(hammer_inode_t ip, struct hammer_ioc_history *hist,
157 hammer_btree_elm_t elm);
161 hammer_ioc_gethistory(hammer_transaction_t trans, hammer_inode_t ip,
162 struct hammer_ioc_history *hist)
164 struct hammer_cursor cursor;
165 hammer_btree_elm_t elm;
169 * Validate the structure and initialize for return.
171 if (hist->beg_tid > hist->end_tid)
173 if (hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) {
174 if (hist->key > hist->nxt_key)
178 hist->obj_id = ip->obj_id;
180 hist->nxt_tid = hist->end_tid;
181 hist->head.flags &= ~HAMMER_IOC_HISTORY_NEXT_TID;
182 hist->head.flags &= ~HAMMER_IOC_HISTORY_NEXT_KEY;
183 hist->head.flags &= ~HAMMER_IOC_HISTORY_EOF;
184 hist->head.flags &= ~HAMMER_IOC_HISTORY_UNSYNCED;
185 if ((ip->flags & HAMMER_INODE_MODMASK) &
186 ~(HAMMER_INODE_ATIME | HAMMER_INODE_MTIME)) {
187 hist->head.flags |= HAMMER_IOC_HISTORY_UNSYNCED;
191 * Setup the cursor. We can't handle undeletable records
192 * (create_tid of 0) at the moment. A create_tid of 0 has
193 * a special meaning and cannot be specified in the cursor.
195 error = hammer_init_cursor(trans, &cursor, &ip->cache[0], NULL);
197 hammer_done_cursor(&cursor);
201 cursor.key_beg.obj_id = hist->obj_id;
202 cursor.key_beg.create_tid = hist->beg_tid;
203 cursor.key_beg.delete_tid = 0;
204 cursor.key_beg.obj_type = 0;
205 if (cursor.key_beg.create_tid == HAMMER_MIN_TID)
206 cursor.key_beg.create_tid = 1;
208 cursor.key_end.obj_id = hist->obj_id;
209 cursor.key_end.create_tid = hist->end_tid;
210 cursor.key_end.delete_tid = 0;
211 cursor.key_end.obj_type = 0;
213 cursor.flags |= HAMMER_CURSOR_END_EXCLUSIVE;
215 if (hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) {
217 * key-range within the file. For a regular file the
218 * on-disk key represents BASE+LEN, not BASE, so the
219 * first possible record containing the offset 'key'
220 * has an on-disk key of (key + 1).
222 cursor.key_beg.key = hist->key;
223 cursor.key_end.key = HAMMER_MAX_KEY;
224 cursor.key_beg.localization = ip->obj_localization +
225 HAMMER_LOCALIZE_MISC;
226 cursor.key_end.localization = ip->obj_localization +
227 HAMMER_LOCALIZE_MISC;
229 switch(ip->ino_data.obj_type) {
230 case HAMMER_OBJTYPE_REGFILE:
231 ++cursor.key_beg.key;
232 cursor.key_beg.rec_type = HAMMER_RECTYPE_DATA;
234 case HAMMER_OBJTYPE_DIRECTORY:
235 cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
236 cursor.key_beg.localization =
237 hammer_dir_localization(ip);
238 cursor.key_end.localization =
239 hammer_dir_localization(ip);
241 case HAMMER_OBJTYPE_DBFILE:
242 cursor.key_beg.rec_type = HAMMER_RECTYPE_DB;
248 cursor.key_end.rec_type = cursor.key_beg.rec_type;
253 cursor.key_beg.key = 0;
254 cursor.key_end.key = 0;
255 cursor.key_beg.rec_type = HAMMER_RECTYPE_INODE;
256 cursor.key_end.rec_type = HAMMER_RECTYPE_INODE;
257 cursor.key_beg.localization = ip->obj_localization +
258 HAMMER_LOCALIZE_INODE;
259 cursor.key_end.localization = ip->obj_localization +
260 HAMMER_LOCALIZE_INODE;
263 error = hammer_btree_first(&cursor);
265 elm = &cursor.node->ondisk->elms[cursor.index];
267 add_history(ip, hist, elm);
268 if (hist->head.flags & (HAMMER_IOC_HISTORY_NEXT_TID |
269 HAMMER_IOC_HISTORY_NEXT_KEY |
270 HAMMER_IOC_HISTORY_EOF)) {
273 error = hammer_btree_iterate(&cursor);
275 if (error == ENOENT) {
276 hist->head.flags |= HAMMER_IOC_HISTORY_EOF;
279 hammer_done_cursor(&cursor);
284 * Add the scanned element to the ioctl return structure. Some special
285 * casing is required for regular files to accomodate how data ranges are
289 add_history(hammer_inode_t ip, struct hammer_ioc_history *hist,
290 hammer_btree_elm_t elm)
294 if (elm->base.btype != HAMMER_BTREE_TYPE_RECORD)
296 if ((hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) &&
297 ip->ino_data.obj_type == HAMMER_OBJTYPE_REGFILE) {
301 if (hist->nxt_key > elm->leaf.base.key - elm->leaf.data_len &&
302 hist->key < elm->leaf.base.key - elm->leaf.data_len) {
303 hist->nxt_key = elm->leaf.base.key - elm->leaf.data_len;
305 if (hist->nxt_key > elm->leaf.base.key)
306 hist->nxt_key = elm->leaf.base.key;
309 * Record is beyond MAXPHYS, there won't be any more records
310 * in the iteration covering the requested offset (key).
312 if (elm->leaf.base.key >= MAXPHYS &&
313 elm->leaf.base.key - MAXPHYS > hist->key) {
314 hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_KEY;
318 * Data-range of record does not cover the key.
320 if (elm->leaf.base.key - elm->leaf.data_len > hist->key)
323 } else if (hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) {
327 if (hist->nxt_key > elm->leaf.base.key &&
328 hist->key < elm->leaf.base.key) {
329 hist->nxt_key = elm->leaf.base.key;
333 * Record is beyond the requested key.
335 if (elm->leaf.base.key > hist->key)
336 hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_KEY;
340 * Add create_tid if it is in-bounds.
344 elm->leaf.base.create_tid != hist->hist_ary[i - 1].tid) &&
345 elm->leaf.base.create_tid >= hist->beg_tid &&
346 elm->leaf.base.create_tid < hist->end_tid) {
347 if (hist->count == HAMMER_MAX_HISTORY_ELMS) {
348 hist->nxt_tid = elm->leaf.base.create_tid;
349 hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_TID;
352 hist->hist_ary[i].tid = elm->leaf.base.create_tid;
353 hist->hist_ary[i].time32 = elm->leaf.create_ts;
358 * Add delete_tid if it is in-bounds. Note that different portions
359 * of the history may have overlapping data ranges with different
360 * delete_tid's. If this case occurs the delete_tid may match the
361 * create_tid of a following record. XXX
367 if (elm->leaf.base.delete_tid &&
368 elm->leaf.base.delete_tid >= hist->beg_tid &&
369 elm->leaf.base.delete_tid < hist->end_tid) {
370 if (i == HAMMER_MAX_HISTORY_ELMS) {
371 hist->nxt_tid = elm->leaf.base.delete_tid;
372 hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_TID;
375 hist->hist_ary[i].tid = elm->leaf.base.delete_tid;
376 hist->hist_ary[i].time32 = elm->leaf.delete_ts;
382 * Acquire synchronization TID
386 hammer_ioc_synctid(hammer_transaction_t trans, hammer_inode_t ip,
387 struct hammer_ioc_synctid *std)
389 hammer_mount_t hmp = ip->hmp;
393 case HAMMER_SYNCTID_NONE:
394 std->tid = hmp->flusher.tid; /* inaccurate */
396 case HAMMER_SYNCTID_ASYNC:
397 hammer_queue_inodes_flusher(hmp, MNT_NOWAIT);
398 hammer_flusher_async(hmp, NULL);
399 std->tid = hmp->flusher.tid; /* inaccurate */
401 case HAMMER_SYNCTID_SYNC1:
402 hammer_queue_inodes_flusher(hmp, MNT_WAIT);
403 hammer_flusher_sync(hmp);
404 std->tid = hmp->flusher.tid;
406 case HAMMER_SYNCTID_SYNC2:
407 hammer_queue_inodes_flusher(hmp, MNT_WAIT);
408 hammer_flusher_sync(hmp);
409 std->tid = hmp->flusher.tid;
410 hammer_flusher_sync(hmp);
420 * Retrieve version info.
422 * Load min_version, wip_version, and max_versino. If cur_version is passed
423 * as 0 then load the current version into cur_version. Load the description
424 * for cur_version into the description array.
426 * Returns 0 on success, EINVAL if cur_version is non-zero and set to an
431 hammer_ioc_get_version(hammer_transaction_t trans, hammer_inode_t ip,
432 struct hammer_ioc_version *ver)
436 ver->min_version = HAMMER_VOL_VERSION_MIN;
437 ver->wip_version = HAMMER_VOL_VERSION_WIP;
438 ver->max_version = HAMMER_VOL_VERSION_MAX;
439 if (ver->cur_version == 0)
440 ver->cur_version = trans->hmp->version;
441 switch(ver->cur_version) {
443 ksnprintf(ver->description, sizeof(ver->description),
444 "2.0 - First HAMMER release");
447 ksnprintf(ver->description, sizeof(ver->description),
448 "2.3 - New directory entry layout");
451 ksnprintf(ver->description, sizeof(ver->description),
464 hammer_ioc_set_version(hammer_transaction_t trans, hammer_inode_t ip,
465 struct hammer_ioc_version *ver)
467 struct hammer_cursor cursor;
468 hammer_volume_t volume;
471 if (ver->cur_version < trans->hmp->version)
473 if (ver->cur_version == trans->hmp->version)
475 if (ver->cur_version > HAMMER_VOL_VERSION_MAX)
477 if (trans->hmp->ronly)
481 * Update the root volume header and the version cached in
482 * the hammer_mount structure.
484 error = hammer_init_cursor(trans, &cursor, NULL, NULL);
487 hammer_sync_lock_sh(trans);
489 volume = hammer_get_root_volume(cursor.trans->hmp, &error);
490 KKASSERT(error == 0);
491 hammer_modify_volume_field(cursor.trans, volume, vol_version);
492 volume->ondisk->vol_version = ver->cur_version;
493 cursor.trans->hmp->version = ver->cur_version;
494 hammer_modify_volume_done(volume);
495 hammer_rel_volume(volume, 0);
497 hammer_sync_unlock(trans);
499 ver->head.error = error;
500 hammer_done_cursor(&cursor);