int (*rsyscall)(int, long, long, long, long, long, long);
void (**tsd_keys)(void *);
void (*fork_handler)(int);
+ FILE *ofl_head;
+ int ofl_lock;
+ void (*lockfile)(FILE *);
};
/* Designed to avoid any overhead in non-threaded processes */
void __lock(volatile int *);
+void __lockfile(FILE *);
#define LOCK(x) (libc.threads_minus_1 ? (__lock(x),1) : ((void)(x),1))
#define UNLOCK(x) (*(x)=0)
#define CANCELPT(x) (libc.cancelpt ? libc.cancelpt((x)),0 : (void)(x),0)
#define UNGET 4
-#define FLOCK(f) LOCK(&f->lock)
-#define FUNLOCK(f) UNLOCK(&f->lock)
+#define FLOCK(f) ((libc.lockfile && (f)->owner>=0) ? (libc.lockfile((f)),0) : 0)
+#define FUNLOCK(f) ((f)->lockcount && (--(f)->lockcount || ((f)->owner=(f)->lock=0)))
#define F_PERM 1
#define F_NORD 4
signed char lbf;
int lock;
int lockcount;
- void *owner;
+ void *dummy5;
off_t off;
int (*flush)(FILE *);
void **wide_data; /* must be NULL */
off_t (*seek)(FILE *, off_t, int);
int mode;
int (*close)(FILE *);
+ int owner;
};
size_t __stdio_read(FILE *, unsigned char *, size_t);
FILE *__fdopen(int, const char *);
-extern struct ofl
-{
- FILE *head;
- int lock;
-} __ofl;
-
-#define OFLLOCK() LOCK(&__ofl.lock)
-#define OFLUNLOCK() UNLOCK(&__ofl.lock)
-#define ofl_head (__ofl.head)
+#define OFLLOCK() LOCK(&libc.ofl_lock)
+#define OFLUNLOCK() UNLOCK(&libc.ofl_lock)
+#define ofl_head (libc.ofl_head)
#define feof(f) ((f)->flags & F_EOF)
#define ferror(f) ((f)->flags & F_ERR)
--- /dev/null
+#include "stdio_impl.h"
+#include "pthread_impl.h"
+
+void __lockfile(FILE *f)
+{
+ int spins;
+ if (f->owner < 0) return;
+ if (f->owner && f->owner == __pthread_self()->tid) {
+ while (f->lockcount == INT_MAX);
+ f->lockcount++;
+ return;
+ }
+ spins = 100000;
+ while (a_swap(&f->lock, 1))
+ if (spins) spins--, a_spin();
+ else syscall0(__NR_sched_yield);
+ f->owner = __pthread_self()->tid;
+ f->lockcount = 1;
+}
+++ /dev/null
-#include "stdio_impl.h"
-
-struct ofl __ofl;
--- /dev/null
+#include "stdio_impl.h"
+#include "pthread_impl.h"
+
+void flockfile(FILE *f)
+{
+ pthread_self();
+ libc.lockfile = __lockfile;
+ __lockfile(f);
+}
--- /dev/null
+#include "stdio_impl.h"
+#include "pthread_impl.h"
+
+int ftrylockfile(FILE *f)
+{
+ libc.lockfile = __lockfile;
+ if (f->owner && f->owner == pthread_self()->tid) {
+ if (f->lockcount == INT_MAX)
+ return -1;
+ f->lockcount++;
+ return 0;
+ }
+ if (a_swap(&f->lock, 1))
+ return -1;
+ f->owner = pthread_self()->tid;
+ f->lockcount = 1;
+ return 0;
+}
--- /dev/null
+#include "stdio_impl.h"
+#include "pthread_impl.h"
+
+void funlockfile(FILE *f)
+{
+ FUNLOCK(f);
+}
f.write = sn_write;
f.buf_size = 1;
f.buf = buf;
+ f.owner = -1;
if (n > INT_MAX) {
errno = EOVERFLOW;
return -1;
{
struct sigaction sa = { .sa_flags = SA_SIGINFO | SA_RESTART };
libc.lock = __lock;
+ libc.lockfile = __lockfile;
libc.cancelpt = cancelpt;
libc.rsyscall = rsyscall;
sa.sa_sigaction = cancel_handler;