head 1.9; access; symbols pkgsrc-2013Q2:1.9.0.4 pkgsrc-2013Q2-base:1.9 pkgsrc-2012Q4:1.9.0.2 pkgsrc-2012Q4-base:1.9 pkgsrc-2012Q3:1.8.0.8 pkgsrc-2012Q3-base:1.8 pkgsrc-2012Q2:1.8.0.6 pkgsrc-2012Q2-base:1.8 pkgsrc-2012Q1:1.8.0.4 pkgsrc-2012Q1-base:1.8 pkgsrc-2011Q4:1.8.0.2 pkgsrc-2011Q4-base:1.8 pkgsrc-2011Q3:1.6.0.2 pkgsrc-2011Q3-base:1.6 pkgsrc-2011Q2:1.3.0.2 pkgsrc-2011Q2-base:1.3 pkgsrc-2011Q1:1.1.1.1.0.6 pkgsrc-2011Q1-base:1.1.1.1 pkgsrc-2010Q4:1.1.1.1.0.4 pkgsrc-2010Q4-base:1.1.1.1 pkgsrc-2010Q3:1.1.1.1.0.2 pkgsrc-2010Q3-base:1.1.1.1 pkgsrc-base:1.1.1.1 TNF:1.1.1; locks; strict; comment @# @; 1.9 date 2012.10.19.04.15.21; author manu; state dead; branches; next 1.8; 1.8 date 2011.12.09.16.57.44; author manu; state Exp; branches; next 1.7; 1.7 date 2011.11.28.08.42.39; author manu; state Exp; branches; next 1.6; 1.6 date 2011.07.23.01.14.44; author manu; state Exp; branches; next 1.5; 1.5 date 2011.07.19.07.54.31; author manu; state Exp; branches; next 1.4; 1.4 date 2011.07.08.08.02.57; author manu; state Exp; branches; next 1.3; 1.3 date 2011.05.19.14.54.23; author manu; state Exp; branches; next 1.2; 1.2 date 2011.04.18.16.19.48; author manu; state Exp; branches; next 1.1; 1.1 date 2010.08.26.14.26.19; author manu; state Exp; branches 1.1.1.1; next ; 1.1.1.1 date 2010.08.26.14.26.19; author manu; state Exp; branches; next ; desc @@ 1.9 log @Bump to glusterfs-3.3.1, which brings - unified file and object storage - storage for Hadoop (not tested here) - proactive self-healing - much better performance @ text @$NetBSD: patch-be,v 1.8 2011/12/09 16:57:44 manu Exp $ basename() and dirname() are not supposed to be thread-safe, and NetBSD's implementation is not. glusterfs assume the functions are thread-safe. Borrow basename() and rdirname() form glibc and make NetBSD use them. --- libglusterfs/src/compat.c.orig 2011-11-27 07:55:13.000000000 +0100 +++ libglusterfs/src/compat.c 2011-11-27 07:55:13.000000000 +0100 @@@@ -550,8 +550,412 @@@@ #endif /* GF_SOLARIS_HOST_OS */ +#ifdef __NetBSD__ +/* + * basename() and dirname() are not supposed to be thread-safe. + * SUSv2 states it can return a static pointer, and NetBSD does that. + * glusterfs heavily assume basename() and dirname() thread-safety, + * hence these replacement from glibc. + * compat.h defines basename() and dirname() as macro so that + * the replacement are used. + */ + +/* + * borrowed from glibc-2.12.1/string/basename.c (GPL 2.1 or later) + * Copyright (C) 1996,97,98,2002 Free Software Foundation, Inc. + * Modified to return "." for NULL or "", as required for SUSv2. + */ +char * +basename_r (filename) + const char *filename; +{ + char *p; + + if ((filename == NULL) || (*filename == '\0')) + return "."; + + p = strrchr (filename, '/'); + return p ? p + 1 : (char *) filename; +} + +/* + * Borrowed from blibc-2.12.1/string/memrchr.c (GPL 2.1 or later) + * Copyright (C) 1991, 93, 96, 97, 99, 2000 Free Software Foundation, Inc. + * Based on strlen implementation by Torbjorn Granlund (tege@@sics.se), + * Removed code for long bigger than 32 bytes, renamed __ptr_t as void * + * changed reg_char type to char. + */ +void * +__memrchr (s, c_in, n) + const void * s; + int c_in; + size_t n; +{ + const unsigned char *char_ptr; + const unsigned long int *longword_ptr; + unsigned long int longword, magic_bits, charmask; + unsigned char c; + + c = (unsigned char) c_in; + + /* Handle the last few characters by reading one character at a time. + Do this until CHAR_PTR is aligned on a longword boundary. */ + for (char_ptr = (const unsigned char *) s + n; + n > 0 && ((unsigned long int) char_ptr + & (sizeof (longword) - 1)) != 0; + --n) + if (*--char_ptr == c) + return (void *) char_ptr; + + /* All these elucidatory comments refer to 4-byte longwords, + but the theory applies equally well to 8-byte longwords. */ + + longword_ptr = (const unsigned long int *) char_ptr; + + /* Bits 31, 24, 16, and 8 of this number are zero. Call these bits + the "holes." Note that there is a hole just to the left of + each byte, with an extra at the end: + + bits: 01111110 11111110 11111110 11111111 + bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD + + The 1-bits make sure that carries propagate to the next 0-bit. + The 0-bits provide holes for carries to fall into. */ + + if (sizeof (longword) != 4 && sizeof (longword) != 8) + abort (); + + magic_bits = 0x7efefeff; + + /* Set up a longword, each of whose bytes is C. */ + charmask = c | (c << 8); + charmask |= charmask << 16; + + /* Instead of the traditional loop which tests each character, + we will test a longword at a time. The tricky part is testing + if *any of the four* bytes in the longword in question are zero. */ + while (n >= sizeof (longword)) + { + /* We tentatively exit the loop if adding MAGIC_BITS to + LONGWORD fails to change any of the hole bits of LONGWORD. + + 1) Is this safe? Will it catch all the zero bytes? + Suppose there is a byte with all zeros. Any carry bits + propagating from its left will fall into the hole at its + least significant bit and stop. Since there will be no + carry from its most significant bit, the LSB of the + byte to the left will be unchanged, and the zero will be + detected. + + 2) Is this worthwhile? Will it ignore everything except + zero bytes? Suppose every byte of LONGWORD has a bit set + somewhere. There will be a carry into bit 8. If bit 8 + is set, this will carry into bit 16. If bit 8 is clear, + one of bits 9-15 must be set, so there will be a carry + into bit 16. Similarly, there will be a carry into bit + 24. If one of bits 24-30 is set, there will be a carry + into bit 31, so all of the hole bits will be changed. + + The one misfire occurs when bits 24-30 are clear and bit + 31 is set; in this case, the hole at bit 31 is not + changed. If we had access to the processor carry flag, + we could close this loophole by putting the fourth hole + at bit 32! + + So it ignores everything except 128's, when they're aligned + properly. + + 3) But wait! Aren't we looking for C, not zero? + Good point. So what we do is XOR LONGWORD with a longword, + each of whose bytes is C. This turns each byte that is C + into a zero. */ + + longword = *--longword_ptr ^ charmask; + + /* Add MAGIC_BITS to LONGWORD. */ + if ((((longword + magic_bits) + + /* Set those bits that were unchanged by the addition. */ + ^ ~longword) + + /* Look at only the hole bits. If any of the hole bits + are unchanged, most likely one of the bytes was a + zero. */ + & ~magic_bits) != 0) + { + /* Which of the bytes was C? If none of them were, it was + a misfire; continue the search. */ + + const unsigned char *cp = (const unsigned char *) longword_ptr; + + if (cp[3] == c) + return (void *) &cp[3]; + if (cp[2] == c) + return (void *) &cp[2]; + if (cp[1] == c) + return (void *) &cp[1]; + if (cp[0] == c) + return (void *) cp; + } + + n -= sizeof (longword); + } + + char_ptr = (const unsigned char *) longword_ptr; + + while (n-- > 0) + { + if (*--char_ptr == c) + return (void *) char_ptr; + } + + return 0; +} + +/* + * Borrowed from glibc-2.12.1/misc/dirname.c (GPL 2.1 or later) + * Copyright (C) 1996, 2000, 2001, 2002 Free Software Foundation, Inc. + * Contributed by Ulrich Drepper , 1996. + */ +char * +dirname_r (char *path) +{ + static const char dot[] = "."; + char *last_slash; + + /* Find last '/'. */ + last_slash = path != NULL ? strrchr (path, '/') : NULL; + + if (last_slash != NULL && last_slash != path && last_slash[1] == '\0') + { + /* Determine whether all remaining characters are slashes. */ + char *runp; + + for (runp = last_slash; runp != path; --runp) + if (runp[-1] != '/') + break; + + /* The '/' is the last character, we have to look further. */ + if (runp != path) + last_slash = __memrchr (path, '/', runp - path); + } + + if (last_slash != NULL) + { + /* Determine whether all remaining characters are slashes. */ + char *runp; + + for (runp = last_slash; runp != path; --runp) + if (runp[-1] != '/') + break; + + /* Terminate the path. */ + if (runp == path) + { + /* The last slash is the first character in the string. We have to + return "/". As a special case we have to return "//" if there + are exactly two slashes at the beginning of the string. See + XBD 4.10 Path Name Resolution for more information. */ + if (last_slash == path + 1) + ++last_slash; + else + last_slash = path + 1; + } + else + last_slash = runp; + + last_slash[0] = '\0'; + } + else + /* This assignment is ill-designed but the XPG specs require to + return a string containing "." in any case no directory part is + found and so a static and constant string is required. */ + path = (char *) dot; + + return path; +} +#ifndef HAVE_SYS_XATTR_H + +#define MATCH_NS(ns, key) (strncmp(ns, key, sizeof(ns) - 1) == 0) +static int +xattr_native_ns(const char *key) { + if (MATCH_NS("system.", key)) + return EXTATTR_NAMESPACE_SYSTEM; + else if (MATCH_NS("user.", key)) + return EXTATTR_NAMESPACE_USER; + else if (MATCH_NS("security.", key)) + return EXTATTR_NAMESPACE_SYSTEM; + else if (MATCH_NS("trusted.", key)) + return EXTATTR_NAMESPACE_SYSTEM; + else + return EXTATTR_NAMESPACE_USER; + +} +#undef MATCH_NS + +static void +xattr_native_list(char *data, ssize_t len) { + int i; + size_t attrlen; + + for (i = 0; i < len; i += attrlen + 1) { + attrlen = (size_t)data[i]; + memmove(data + i, data + i + 1, attrlen); + data[i + attrlen] = 0; + } + + return; +} + +int +removexattr(const char *path, const char *key) +{ + return extattr_delete_file(path, xattr_native_ns(key), key); +} + +ssize_t +listxattr(const char *path, void *value, size_t size) +{ + ssize_t syslen; + ssize_t usrlen; + + usrlen = extattr_list_file(path, EXTATTR_NAMESPACE_USER, value, size); + if (usrlen == -1) + return -1; + + if (value != NULL) { + xattr_native_list(value, usrlen); + value += usrlen; + size -= usrlen; + } + + syslen = extattr_list_file(path, EXTATTR_NAMESPACE_SYSTEM, value, size); + if (usrlen == -1) + return usrlen; + + if (value != NULL) + xattr_native_list(value, syslen); + + return usrlen + syslen; +} + +ssize_t +getxattr(const char *path, const char *key, void *value, size_t size) +{ + return extattr_get_file(path, xattr_native_ns(key), key, value, size); +} + +int +setxattr(const char *path, const char *key, const void *value, size_t size) +{ + ssize_t ret; + + ret = extattr_set_file(path, xattr_native_ns(key), key, value, size); + + return (ret == -1) ? -1 : 0; +} + +int +fremovexattr(int fd, const char *key) +{ + return extattr_delete_fd(fd, xattr_native_ns(key), key); +} + +ssize_t +flistxattr(int fd, void *value, size_t size) +{ + ssize_t syslen; + ssize_t usrlen; + + usrlen = extattr_list_fd(fd, EXTATTR_NAMESPACE_USER, value, size); + if (usrlen == -1) + return -1; + + if (value != NULL) { + xattr_native_list(value, usrlen); + value += usrlen; + size -= usrlen; + } + + syslen = extattr_list_fd(fd, EXTATTR_NAMESPACE_SYSTEM, value, size); + if (usrlen == -1) + return usrlen; + + if (value != NULL) + xattr_native_list(value, syslen); + + return usrlen + syslen; +} + +ssize_t +fgetxattr(int fd, const char *key, void *value, size_t size) +{ + return extattr_get_fd(fd, xattr_native_ns(key), key, value, size); +} + +int +fsetxattr(int fd, const char *key, const void *value, size_t size) +{ + ssize_t ret; + + ret = extattr_set_fd(fd, xattr_native_ns(key), key, value, size); + + return (ret == -1) ? -1 : 0; +} + +int +lremovexattr(const char *path, const char *key) +{ + return extattr_delete_link(path, xattr_native_ns(key), key); +} + +ssize_t +llistxattr(const char *path, void *value, size_t size) +{ + ssize_t syslen; + ssize_t usrlen; + + usrlen = extattr_list_link(path, EXTATTR_NAMESPACE_USER, value, size); + if (usrlen == -1) + return -1; + + if (value != NULL) { + xattr_native_list(value, usrlen); + value += usrlen; + size -= usrlen; + } + + syslen = extattr_list_link(path, EXTATTR_NAMESPACE_SYSTEM, value, size); + if (usrlen == -1) + return usrlen; + + if (value != NULL) + xattr_native_list(value, syslen); + + return usrlen + syslen; +} + +ssize_t +lgetxattr(const char *path, const char *key, void *value, size_t size) +{ + return extattr_get_link(path, xattr_native_ns(key), key, value, size); +} + +int +lsetxattr(const char *path, const char *key, const void *value, size_t size) +{ + ssize_t ret; + + ret = extattr_set_link(path, xattr_native_ns(key), key, value, size); + + return (ret == -1) ? -1 : 0; +} + +#endif /* HAVE_SYS_XATTR_H */ +#endif /* __NetBSD__ */ + #ifndef HAVE_STRNLEN size_t strnlen(const char *string, size_t maxlen) { @ 1.8 log @- Add experimental support for SSL - Ignore again .attribute (a patch part that was lost in last upgrade) @ text @d1 1 a1 1 $NetBSD: patch-be,v 1.6 2011/07/23 01:14:44 manu Exp $ @ 1.7 log @Update to glusterfs 3.2.5. This is a bug-fix release @ text @@ 1.6 log @Update to glusterfs 3.2.2 (maintenance release for bug fixes) @ text @d1 1 a1 1 $NetBSD$ d7 4 a10 3 --- libglusterfs/src/compat.c.orig 2011-07-14 14:21:10.000000000 +0200 +++ libglusterfs/src/compat.c 2011-07-22 09:00:15.000000000 +0200 @@@@ -529,8 +529,412 @@@@ a11 1 } @ 1.5 log @Enable georeplication @ text @d7 2 a8 2 --- libglusterfs/src/compat.c.orig 2011-06-10 16:59:04.000000000 +0000 +++ libglusterfs/src/compat.c 2011-07-08 01:37:36.000000000 +0000 @ 1.4 log @Upgrade to glusterfs-3.2.1 This release is mostly about bug fixes, and we also fix bugs in the NetBSD port. @ text @@ 1.3 log @Update glusterfs to 3.2. According to http://www.gluster.org, news are: * Geo-Replication * Easily Accessible Usage Quotas * Advanced Monitoring Tools @ text @d1 9 a9 3 --- libglusterfs/src/compat.c.orig 2011-04-22 19:37:28.000000000 +0200 +++ libglusterfs/src/compat.c 2011-05-19 15:27:32.000000000 +0200 @@@@ -529,8 +529,285 @@@@ d238 32 a270 3 +/* + * Extended attribute API for NetBSD + */ d273 3 a275 1 +{ return extattr_delete_file(path, EXTATTR_NAMESPACE_USER, key); } d279 23 a301 1 +{ return extattr_list_file(path, EXTATTR_NAMESPACE_USER, value, size); } d305 3 a307 1 +{ return extattr_get_file(path, EXTATTR_NAMESPACE_USER, key, value, size); } d311 7 a317 1 +{ return extattr_set_file(path, EXTATTR_NAMESPACE_USER, key, value, size); } d321 3 a323 1 +{ return extattr_delete_fd(fd, EXTATTR_NAMESPACE_USER, key); } d327 23 a349 1 +{ return extattr_list_fd(fd, EXTATTR_NAMESPACE_USER, value, size); } d353 3 a355 1 +{ return extattr_get_fd(fd, EXTATTR_NAMESPACE_USER, key, value, size); } d359 7 a365 1 +{ return extattr_set_fd(fd, EXTATTR_NAMESPACE_USER, key, value, size); } d369 3 a371 1 +{ return extattr_delete_link(path, EXTATTR_NAMESPACE_USER, key); } d375 23 a397 1 +{ return extattr_list_link(path, EXTATTR_NAMESPACE_USER, value, size); } d401 3 a403 1 +{ return extattr_get_link(path, EXTATTR_NAMESPACE_USER, key, value, size); } d407 4 a410 1 +{ return extattr_set_link(path, EXTATTR_NAMESPACE_USER, key, value, size); } d412 4 d417 1 @ 1.2 log @Update glusterfs to 3.1.4. Major new features according to http://www.gluster.org/ - Elastic Volume Management - New Gluster Console Manager - Dynamic Storage for the data center and cloud @ text @d1 4 a4 13 $NetBSD: patch-be,v 1.1.1.1 2010/08/26 14:26:19 manu Exp $ basename() and dirname() are not supposed to be thread-safe, and NetBSD's implementation is not. glusterfs assume the functions are thread-safe. Borrow basename() and rdirname() form glibc and make NetBSD use them. Also map Linux extended attribute system calls to NetBSD counterpart --- libglusterfs/src/compat.c.orig 2011-04-09 10:09:02.000000000 +0200 +++ libglusterfs/src/compat.c 2011-04-14 10:36:40.000000000 +0200 @@@@ -547,4 +547,282 @@@@ len++; return len; d6 2 a7 2 #endif /* STRNLEN */ + d285 4 @ 1.1 log @Initial revision @ text @d1 1 a1 1 $NetBSD$ d7 5 a11 3 --- libglusterfs/src/compat.c.orig 2010-08-25 03:58:44.000000000 +0200 +++ libglusterfs/src/compat.c 2010-08-25 10:42:37.000000000 +0200 @@@@ -509,4 +509,230 @@@@ d20 2 a21 2 + * SUSv2 states it can return a static pointer, and * NetBSD does that. + * glusterfs heavily assume basename() and * dirname() thread-safety, d241 52 @ 1.1.1.1 log @This is an experimental port of glusterfs on NetBSD. Don't do this at home! @ text @@