HAMMER 60C/many: Mirroring
[dragonfly.git] / sys / vfs / hammer / hammer_subs.c
1 /*
2  * Copyright (c) 2007-2008 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
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
16  *    distribution.
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.
20  * 
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
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sys/vfs/hammer/hammer_subs.c,v 1.29 2008/07/04 07:25:36 dillon Exp $
35  */
36 /*
37  * HAMMER structural locking
38  */
39
40 #include "hammer.h"
41 #include <sys/dirent.h>
42
43 void
44 hammer_lock_ex_ident(struct hammer_lock *lock, const char *ident)
45 {
46         thread_t td = curthread;
47
48         KKASSERT(lock->refs > 0);
49         crit_enter();
50         if (lock->locktd != td) {
51                 while (lock->locktd != NULL || lock->lockcount) {
52                         ++lock->exwanted;
53                         lock->wanted = 1;
54                         if (hammer_debug_locks) {
55                                 kprintf("hammer_lock_ex: held by %p\n",
56                                         lock->locktd);
57                         }
58                         ++hammer_contention_count;
59                         tsleep(lock, 0, ident, 0);
60                         if (hammer_debug_locks)
61                                 kprintf("hammer_lock_ex: try again\n");
62                         --lock->exwanted;
63                 }
64                 lock->locktd = td;
65         }
66         KKASSERT(lock->lockcount >= 0);
67         ++lock->lockcount;
68         crit_exit();
69 }
70
71 /*
72  * Try to obtain an exclusive lock
73  */
74 int
75 hammer_lock_ex_try(struct hammer_lock *lock)
76 {
77         thread_t td = curthread;
78
79         KKASSERT(lock->refs > 0);
80         crit_enter();
81         if (lock->locktd != td) {
82                 if (lock->locktd != NULL || lock->lockcount) {
83                         crit_exit();
84                         return(EAGAIN);
85                 }
86                 lock->locktd = td;
87         }
88         KKASSERT(lock->lockcount >= 0);
89         ++lock->lockcount;
90         crit_exit();
91         return(0);
92 }
93
94 /*
95  * Obtain a shared lock
96  */
97 void
98 hammer_lock_sh(struct hammer_lock *lock)
99 {
100         KKASSERT(lock->refs > 0);
101         crit_enter();
102         while (lock->locktd != NULL) {
103                 if (lock->locktd == curthread) {
104                         Debugger("hammer_lock_sh: lock_sh on exclusive");
105                         ++lock->lockcount;
106                         crit_exit();
107                         return;
108                 }
109                 lock->wanted = 1;
110                 tsleep(lock, 0, "hmrlck", 0);
111         }
112         KKASSERT(lock->lockcount <= 0);
113         --lock->lockcount;
114         crit_exit();
115 }
116
117 /*
118  * Obtain a shared lock at a lower priority then thread waiting for an
119  * exclusive lock.  To avoid a deadlock this may only be done if no other
120  * shared locks are being held by the caller.
121  */
122 void
123 hammer_lock_sh_lowpri(struct hammer_lock *lock)
124 {
125         KKASSERT(lock->refs > 0);
126         crit_enter();
127         while (lock->locktd != NULL || lock->exwanted) {
128                 if (lock->locktd == curthread) {
129                         Debugger("hammer_lock_sh: lock_sh on exclusive");
130                         ++lock->lockcount;
131                         crit_exit();
132                         return;
133                 }
134                 lock->wanted = 1;
135                 tsleep(lock, 0, "hmrlck", 0);
136         }
137         KKASSERT(lock->lockcount <= 0);
138         --lock->lockcount;
139         crit_exit();
140 }
141
142 int
143 hammer_lock_sh_try(struct hammer_lock *lock)
144 {
145         KKASSERT(lock->refs > 0);
146         crit_enter();
147         if (lock->locktd) {
148                 crit_exit();
149                 return(EAGAIN);
150         }
151         KKASSERT(lock->lockcount <= 0);
152         --lock->lockcount;
153         crit_exit();
154         return(0);
155 }
156
157 /*
158  * Upgrade a shared lock to an exclusively held lock.  This function will
159  * return EDEADLK If there is more then one shared holder.
160  *
161  * No error occurs and no action is taken if the lock is already exclusively
162  * held by the caller.  If the lock is not held at all or held exclusively
163  * by someone else, this function will panic.
164  */
165 int
166 hammer_lock_upgrade(struct hammer_lock *lock)
167 {
168         int error;
169
170         crit_enter();
171         if (lock->lockcount > 0) {
172                 if (lock->locktd != curthread)
173                         panic("hammer_lock_upgrade: illegal lock state");
174                 error = 0;
175         } else if (lock->lockcount == -1) {
176                 lock->lockcount = 1;
177                 lock->locktd = curthread;
178                 error = 0;
179         } else if (lock->lockcount != 0) {
180                 error = EDEADLK;
181         } else {
182                 panic("hammer_lock_upgrade: lock is not held");
183                 /* NOT REACHED */
184                 error = 0;
185         }
186         crit_exit();
187         return(error);
188 }
189
190 /*
191  * Downgrade an exclusively held lock to a shared lock.
192  */
193 void
194 hammer_lock_downgrade(struct hammer_lock *lock)
195 {
196         KKASSERT(lock->lockcount == 1 && lock->locktd == curthread);
197         crit_enter();
198         lock->lockcount = -1;
199         lock->locktd = NULL;
200         if (lock->wanted) {
201                 lock->wanted = 0;
202                 wakeup(lock);
203         }
204         crit_exit();
205         /* XXX memory barrier */
206 }
207
208 void
209 hammer_unlock(struct hammer_lock *lock)
210 {
211         crit_enter();
212         KKASSERT(lock->lockcount != 0);
213         if (lock->lockcount < 0) {
214                 if (++lock->lockcount == 0 && lock->wanted) {
215                         lock->wanted = 0;
216                         wakeup(lock);
217                 }
218         } else {
219                 KKASSERT(lock->locktd == curthread);
220                 if (--lock->lockcount == 0) {
221                         lock->locktd = NULL;
222                         if (lock->wanted) {
223                                 lock->wanted = 0;
224                                 wakeup(lock);
225                         }
226                 }
227
228         }
229         crit_exit();
230 }
231
232 void
233 hammer_ref(struct hammer_lock *lock)
234 {
235         KKASSERT(lock->refs >= 0);
236         crit_enter();
237         ++lock->refs;
238         crit_exit();
239 }
240
241 void
242 hammer_unref(struct hammer_lock *lock)
243 {
244         KKASSERT(lock->refs > 0);
245         crit_enter();
246         --lock->refs;
247         crit_exit();
248 }
249
250 /*
251  * The sync_lock must be held when doing any modifying operations on
252  * meta-data.  The flusher holds the lock exclusively while the reblocker
253  * and pruner use a shared lock.
254  *
255  * Modifying operations can run in parallel until the flusher needs to
256  * sync the disk media.
257  */
258 void
259 hammer_sync_lock_ex(hammer_transaction_t trans)
260 {
261         ++trans->sync_lock_refs;
262         hammer_lock_ex(&trans->hmp->sync_lock);
263 }
264
265 void
266 hammer_sync_lock_sh(hammer_transaction_t trans)
267 {
268         ++trans->sync_lock_refs;
269         hammer_lock_sh(&trans->hmp->sync_lock);
270 }
271
272 int
273 hammer_sync_lock_sh_try(hammer_transaction_t trans)
274 {
275         int error;
276
277         ++trans->sync_lock_refs;
278         if ((error = hammer_lock_sh_try(&trans->hmp->sync_lock)) != 0)
279                 --trans->sync_lock_refs;
280         return (error);
281 }
282
283 void
284 hammer_sync_unlock(hammer_transaction_t trans)
285 {
286         --trans->sync_lock_refs;
287         hammer_unlock(&trans->hmp->sync_lock);
288 }
289
290 /*
291  * Misc
292  */
293 u_int32_t
294 hammer_to_unix_xid(uuid_t *uuid)
295 {
296         return(*(u_int32_t *)&uuid->node[2]);
297 }
298
299 void
300 hammer_guid_to_uuid(uuid_t *uuid, u_int32_t guid)
301 {
302         bzero(uuid, sizeof(*uuid));
303         *(u_int32_t *)&uuid->node[2] = guid;
304 }
305
306 void
307 hammer_time_to_timespec(u_int64_t xtime, struct timespec *ts)
308 {
309         ts->tv_sec = (unsigned long)(xtime / 1000000);
310         ts->tv_nsec = (unsigned int)(xtime % 1000000) * 1000L;
311 }
312
313 u_int64_t
314 hammer_timespec_to_time(struct timespec *ts)
315 {
316         u_int64_t xtime;
317
318         xtime = (unsigned)(ts->tv_nsec / 1000) +
319                 (unsigned long)ts->tv_sec * 1000000ULL;
320         return(xtime);
321 }
322
323
324 /*
325  * Convert a HAMMER filesystem object type to a vnode type
326  */
327 enum vtype
328 hammer_get_vnode_type(u_int8_t obj_type)
329 {
330         switch(obj_type) {
331         case HAMMER_OBJTYPE_DIRECTORY:
332                 return(VDIR);
333         case HAMMER_OBJTYPE_REGFILE:
334                 return(VREG);
335         case HAMMER_OBJTYPE_DBFILE:
336                 return(VDATABASE);
337         case HAMMER_OBJTYPE_FIFO:
338                 return(VFIFO);
339         case HAMMER_OBJTYPE_CDEV:
340                 return(VCHR);
341         case HAMMER_OBJTYPE_BDEV:
342                 return(VBLK);
343         case HAMMER_OBJTYPE_SOFTLINK:
344                 return(VLNK);
345         default:
346                 return(VBAD);
347         }
348         /* not reached */
349 }
350
351 int
352 hammer_get_dtype(u_int8_t obj_type)
353 {
354         switch(obj_type) {
355         case HAMMER_OBJTYPE_DIRECTORY:
356                 return(DT_DIR);
357         case HAMMER_OBJTYPE_REGFILE:
358                 return(DT_REG);
359         case HAMMER_OBJTYPE_DBFILE:
360                 return(DT_DBF);
361         case HAMMER_OBJTYPE_FIFO:
362                 return(DT_FIFO);
363         case HAMMER_OBJTYPE_CDEV:
364                 return(DT_CHR);
365         case HAMMER_OBJTYPE_BDEV:
366                 return(DT_BLK);
367         case HAMMER_OBJTYPE_SOFTLINK:
368                 return(DT_LNK);
369         default:
370                 return(DT_UNKNOWN);
371         }
372         /* not reached */
373 }
374
375 u_int8_t
376 hammer_get_obj_type(enum vtype vtype)
377 {
378         switch(vtype) {
379         case VDIR:
380                 return(HAMMER_OBJTYPE_DIRECTORY);
381         case VREG:
382                 return(HAMMER_OBJTYPE_REGFILE);
383         case VDATABASE:
384                 return(HAMMER_OBJTYPE_DBFILE);
385         case VFIFO:
386                 return(HAMMER_OBJTYPE_FIFO);
387         case VCHR:
388                 return(HAMMER_OBJTYPE_CDEV);
389         case VBLK:
390                 return(HAMMER_OBJTYPE_BDEV);
391         case VLNK:
392                 return(HAMMER_OBJTYPE_SOFTLINK);
393         default:
394                 return(HAMMER_OBJTYPE_UNKNOWN);
395         }
396         /* not reached */
397 }
398
399 /*
400  * Return flags for hammer_delete_at_cursor()
401  */
402 int
403 hammer_nohistory(hammer_inode_t ip)
404 {
405         if (ip->hmp->hflags & HMNT_NOHISTORY)
406                 return(HAMMER_DELETE_DESTROY);
407         if (ip->ino_data.uflags & (SF_NOHISTORY|UF_NOHISTORY))
408                 return(HAMMER_DELETE_DESTROY);
409         return(0);
410 }
411
412 /*
413  * Return a namekey hash.   The 64 bit namekey hash consists of a 32 bit
414  * crc in the MSB and 0 in the LSB.  The caller will use the low bits to
415  * generate a unique key and will scan all entries with the same upper
416  * 32 bits when issuing a lookup.
417  *
418  * We strip bit 63 in order to provide a positive key, this way a seek
419  * offset of 0 will represent the base of the directory.
420  *
421  * This function can never return 0.  We use the MSB-0 space to synthesize
422  * artificial directory entries such as "." and "..".
423  */
424 int64_t
425 hammer_directory_namekey(const void *name, int len)
426 {
427         int64_t key;
428
429         key = (int64_t)(crc32(name, len) & 0x7FFFFFFF) << 32;
430         if (key == 0)
431                 key |= 0x100000000LL;
432         return(key);
433 }
434
435 hammer_tid_t
436 hammer_str_to_tid(const char *str)
437 {
438         hammer_tid_t tid;
439
440         tid = strtouq(str, NULL, 0);                    /* full TID */
441         return(tid);
442 }
443
444 void
445 hammer_crc_set_blockmap(hammer_blockmap_t blockmap)
446 {
447         blockmap->entry_crc = crc32(blockmap, HAMMER_BLOCKMAP_CRCSIZE);
448 }
449
450 void
451 hammer_crc_set_volume(hammer_volume_ondisk_t ondisk)
452 {
453         ondisk->vol_crc = crc32(ondisk, HAMMER_VOL_CRCSIZE1) ^
454                           crc32(&ondisk->vol_crc + 1, HAMMER_VOL_CRCSIZE2);
455 }
456
457 int
458 hammer_crc_test_blockmap(hammer_blockmap_t blockmap)
459 {
460         hammer_crc_t crc;
461
462         crc = crc32(blockmap, HAMMER_BLOCKMAP_CRCSIZE);
463         return (blockmap->entry_crc == crc);
464 }
465
466 int
467 hammer_crc_test_volume(hammer_volume_ondisk_t ondisk)
468 {
469         hammer_crc_t crc;
470
471         crc = crc32(ondisk, HAMMER_VOL_CRCSIZE1) ^
472               crc32(&ondisk->vol_crc + 1, HAMMER_VOL_CRCSIZE2);
473         return (ondisk->vol_crc == crc);
474 }
475
476 int
477 hammer_crc_test_btree(hammer_node_ondisk_t ondisk)
478 {
479         hammer_crc_t crc;
480
481         crc = crc32(&ondisk->crc + 1, HAMMER_BTREE_CRCSIZE);
482         return (ondisk->crc == crc);
483 }
484
485 /*
486  * Test or set the leaf->data_crc field.  Deal with any special cases given
487  * a generic B-Tree leaf element and its data.
488  *
489  * NOTE: Inode-data: the atime and mtime fields are not CRCd, allowing them
490  *       to be updated in-place.
491  */
492 int
493 hammer_crc_test_leaf(void *data, hammer_btree_leaf_elm_t leaf)
494 {
495         hammer_crc_t crc;
496
497         if (leaf->data_len == 0) {
498                 crc = 0;
499         } else {
500                 switch(leaf->base.rec_type) {
501                 case HAMMER_RECTYPE_INODE:
502                         if (leaf->data_len != sizeof(struct hammer_inode_data))
503                                 return(0);
504                         crc = crc32(data, HAMMER_INODE_CRCSIZE);
505                         break;
506                 default:
507                         crc = crc32(data, leaf->data_len);
508                         break;
509                 }
510         }
511         return (leaf->data_crc == crc);
512 }
513
514 void
515 hammer_crc_set_leaf(void *data, hammer_btree_leaf_elm_t leaf)
516 {
517         if (leaf->data_len == 0) {
518                 leaf->data_crc = 0;
519         } else {
520                 switch(leaf->base.rec_type) {
521                 case HAMMER_RECTYPE_INODE:
522                         KKASSERT(leaf->data_len ==
523                                   sizeof(struct hammer_inode_data));
524                         leaf->data_crc = crc32(data, HAMMER_INODE_CRCSIZE);
525                         break;
526                 default:
527                         leaf->data_crc = crc32(data, leaf->data_len);
528                         break;
529                 }
530         }
531 }
532
533 void
534 hkprintf(const char *ctl, ...)
535 {
536         __va_list va;
537
538         if (hammer_debug_debug) {
539                 __va_start(va, ctl);
540                 kvprintf(ctl, va);
541                 __va_end(va);
542         }
543 }
544
545 /*
546  * Return the block size at the specified file offset.
547  */
548 int
549 hammer_blocksize(int64_t file_offset)
550 {
551         if (file_offset < HAMMER_XDEMARC)
552                 return(HAMMER_BUFSIZE);
553         else
554                 return(HAMMER_XBUFSIZE);
555 }
556
557 /*
558  * Return the demarkation point between the two offsets where
559  * the block size changes. 
560  */
561 int64_t
562 hammer_blockdemarc(int64_t file_offset1, int64_t file_offset2)
563 {
564         if (file_offset1 < HAMMER_XDEMARC) {
565                 if (file_offset2 <= HAMMER_XDEMARC)
566                         return(file_offset2);
567                 return(HAMMER_XDEMARC);
568         }
569         panic("hammer_blockdemarc: illegal range %lld %lld\n",
570               file_offset1, file_offset2);
571 }
572