mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-02-01 03:53:33 +00:00
d95d61b1af
* Better refcounting Cribbed from [Rust Arc][1] and the [Boost docs][2]: """ Increasing the reference counter can always be done with memory_order_relaxed: New references to an object can only be formed from an existing reference, and passing an existing reference from one thread to another must already provide any required synchronization. It is important to enforce any possible access to the object in one thread (through an existing reference) to happen before deleting the object in a different thread. This is achieved by a "release" operation after dropping a reference (any access to the object through this reference must obviously happened before), and an "acquire" operation before deleting the object. It would be possible to use memory_order_acq_rel for the fetch_sub operation, but this results in unneeded "acquire" operations when the reference counter does not yet reach zero and may impose a performance penalty. """ [1] https://moshg.github.io/rust-std-ja/src/alloc/arc.rs.html [2] https://www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html * Make ZiposHandle's pos atomic Implements a somewhat stronger guarantee than POSIX specifies: reads and seeks are atomic. They may be arbitrarily reordered between threads, but each one happens all the way and leaves the fd in a consistent state. This is achieved by "locking" pos in __zipos_read by storing SIZE_MAX to pos during the operation, so only one can be in-flight at a time. Seeks, on the other hand, just update pos in one go, and rerun if it changed in the meantime. I used `LIKELY` / `UNLIKELY` to pessimize the concurrent case; hopefully that buys back some performance.
75 lines
3.2 KiB
C
75 lines
3.2 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright 2021 Justine Alexandra Roberts Tunney │
|
|
│ │
|
|
│ Permission to use, copy, modify, and/or distribute this software for │
|
|
│ any purpose with or without fee is hereby granted, provided that the │
|
|
│ above copyright notice and this permission notice appear in all copies. │
|
|
│ │
|
|
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
|
|
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
|
|
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
|
|
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
|
|
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
|
|
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
|
|
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
|
│ PERFORMANCE OF THIS SOFTWARE. │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "libc/calls/calls.h"
|
|
#include "libc/intrin/atomic.h"
|
|
#include "libc/intrin/likely.h"
|
|
#include "libc/limits.h"
|
|
#include "libc/runtime/zipos.internal.h"
|
|
#include "libc/stdckdint.h"
|
|
#include "libc/sysv/errfuns.h"
|
|
|
|
static int64_t Seek(int64_t pos, int64_t offset) {
|
|
int64_t rc;
|
|
if (!ckd_add(&rc, pos, offset)) {
|
|
if (rc >= 0) {
|
|
return rc;
|
|
} else {
|
|
return einval();
|
|
}
|
|
} else {
|
|
return eoverflow();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Changes current position of zip file handle.
|
|
*
|
|
* @param offset is the relative byte count
|
|
* @param whence can be SEEK_SET, SEEK_CUR, or SEEK_END
|
|
* @return new position relative to beginning, or -1 on error
|
|
* @asyncsignalsafe
|
|
*/
|
|
int64_t __zipos_seek(struct ZiposHandle *h, int64_t offset, unsigned whence) {
|
|
int64_t pos, new_pos;
|
|
while (true) {
|
|
pos = atomic_load_explicit(&h->pos, memory_order_relaxed);
|
|
if (UNLIKELY(pos == SIZE_MAX)) {
|
|
continue;
|
|
}
|
|
switch (whence) {
|
|
case SEEK_SET:
|
|
new_pos = Seek(0, offset);
|
|
break;
|
|
case SEEK_CUR:
|
|
new_pos = Seek(pos, offset);
|
|
break;
|
|
case SEEK_END:
|
|
new_pos = Seek(h->size, offset);
|
|
break;
|
|
default:
|
|
new_pos = einval();
|
|
}
|
|
if (LIKELY(atomic_compare_exchange_weak_explicit(
|
|
&h->pos, &pos, new_pos < 0 ? pos : new_pos, memory_order_acquire,
|
|
memory_order_relaxed))) {
|
|
break;
|
|
}
|
|
}
|
|
return new_pos;
|
|
}
|