Searched hist:b6ee846e (Results 1 – 5 of 5) sorted by relevance
| /freebsd/sys/netpfil/ipfw/ |
| H A D | ip_fw_table.h | b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
|
| H A D | ip_fw_table_algo.c | b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
|
| H A D | ip_fw_private.h | b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
|
| H A D | ip_fw_table.c | b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
|
| H A D | ip_fw_sockopt.c | b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
b6ee846e Sat Aug 02 17:18:47 GMT 2014 Alexander V. Chernikov <melifaro@FreeBSD.org> * Fix case when returning more that 4096 bytes of data
* Use different approach to ensure algo has enough space to store N elements:
- explicitly ask algo (under UH_WLOCK) before/after insertion. This (along
with existing reallocation callbacks) really guarantees us that it is safe
to insert N elements at once while holding UH_WLOCK+WLOCK.
- remove old aflags/flags approach
|