Directory: | cvmfs/ |
---|---|
File: | cvmfs/clientctx.cc |
Date: | 2025-07-06 02:35:01 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 65 | 78 | 83.3% |
Branches: | 22 | 40 | 55.0% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /** | ||
2 | * This file is part of the CernVM File System. | ||
3 | */ | ||
4 | |||
5 | #include "clientctx.h" | ||
6 | |||
7 | #include <cassert> | ||
8 | |||
9 | #include "interrupt.h" | ||
10 | #include "util/concurrency.h" | ||
11 | #include "util/smalloc.h" | ||
12 | |||
13 | using namespace std; // NOLINT | ||
14 | |||
15 | ClientCtx *ClientCtx::instance_ = NULL; | ||
16 | |||
17 | |||
18 | 2366 | void ClientCtx::CleanupInstance() { | |
19 |
2/2✓ Branch 0 taken 1995 times.
✓ Branch 1 taken 371 times.
|
2366 | delete instance_; |
20 | 2366 | instance_ = NULL; | |
21 | 2366 | } | |
22 | |||
23 | |||
24 | 2005 | ClientCtx::ClientCtx() { | |
25 | 2005 | lock_tls_blocks_ = reinterpret_cast<pthread_mutex_t *>( | |
26 | 2005 | smalloc(sizeof(pthread_mutex_t))); | |
27 | 2005 | const int retval = pthread_mutex_init(lock_tls_blocks_, NULL); | |
28 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2005 times.
|
2005 | assert(retval == 0); |
29 | 2005 | } | |
30 | |||
31 | |||
32 | 1995 | ClientCtx::~ClientCtx() { | |
33 | 1995 | pthread_mutex_destroy(lock_tls_blocks_); | |
34 | 1995 | free(lock_tls_blocks_); | |
35 | |||
36 |
2/2✓ Branch 1 taken 342 times.
✓ Branch 2 taken 1995 times.
|
2337 | for (unsigned i = 0; i < tls_blocks_.size(); ++i) { |
37 |
1/2✓ Branch 1 taken 342 times.
✗ Branch 2 not taken.
|
342 | delete tls_blocks_[i]; |
38 | } | ||
39 | |||
40 | 1995 | const int retval = pthread_key_delete(thread_local_storage_); | |
41 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1995 times.
|
1995 | assert(retval == 0); |
42 | 1995 | } | |
43 | |||
44 | |||
45 | 7037 | ClientCtx *ClientCtx::GetInstance() { | |
46 |
2/2✓ Branch 0 taken 2005 times.
✓ Branch 1 taken 5032 times.
|
7037 | if (instance_ == NULL) { |
47 | 2005 | instance_ = new ClientCtx(); | |
48 | 2005 | const int retval = pthread_key_create(&instance_->thread_local_storage_, | |
49 | TlsDestructor); | ||
50 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2005 times.
|
2005 | assert(retval == 0); |
51 | } | ||
52 | |||
53 | 7037 | return instance_; | |
54 | } | ||
55 | |||
56 | |||
57 | 438 | void ClientCtx::Get(uid_t *uid, gid_t *gid, pid_t *pid, InterruptCue **ic) { | |
58 | ThreadLocalStorage *tls = static_cast<ThreadLocalStorage *>( | ||
59 | 438 | pthread_getspecific(thread_local_storage_)); | |
60 |
4/4✓ Branch 0 taken 408 times.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 378 times.
|
438 | if ((tls == NULL) || !tls->is_set) { |
61 | 60 | *uid = -1; | |
62 | 60 | *gid = -1; | |
63 | 60 | *pid = -1; | |
64 | 60 | *ic = NULL; | |
65 | } else { | ||
66 | 378 | *uid = tls->uid; | |
67 | 378 | *gid = tls->gid; | |
68 | 378 | *pid = tls->pid; | |
69 | 378 | *ic = tls->interrupt_cue; | |
70 | } | ||
71 | 438 | } | |
72 | |||
73 | |||
74 | 3251 | bool ClientCtx::IsSet() { | |
75 | ThreadLocalStorage *tls = static_cast<ThreadLocalStorage *>( | ||
76 | 3251 | pthread_getspecific(thread_local_storage_)); | |
77 |
2/2✓ Branch 0 taken 1607 times.
✓ Branch 1 taken 1644 times.
|
3251 | if (tls == NULL) |
78 | 1607 | return false; | |
79 | |||
80 | 1644 | return tls->is_set; | |
81 | } | ||
82 | |||
83 | |||
84 | 1668 | void ClientCtx::Set(uid_t uid, gid_t gid, pid_t pid, InterruptCue *ic) { | |
85 | ThreadLocalStorage *tls = static_cast<ThreadLocalStorage *>( | ||
86 | 1668 | pthread_getspecific(thread_local_storage_)); | |
87 | |||
88 |
2/2✓ Branch 0 taken 342 times.
✓ Branch 1 taken 1326 times.
|
1668 | if (tls == NULL) { |
89 |
1/2✓ Branch 1 taken 342 times.
✗ Branch 2 not taken.
|
342 | tls = new ThreadLocalStorage(uid, gid, pid, ic); |
90 | 342 | const int retval = pthread_setspecific(thread_local_storage_, tls); | |
91 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 342 times.
|
342 | assert(retval == 0); |
92 | 342 | const MutexLockGuard lock_guard(lock_tls_blocks_); | |
93 |
1/2✓ Branch 1 taken 342 times.
✗ Branch 2 not taken.
|
342 | tls_blocks_.push_back(tls); |
94 | 342 | } else { | |
95 | 1326 | tls->uid = uid; | |
96 | 1326 | tls->gid = gid; | |
97 | 1326 | tls->pid = pid; | |
98 | 1326 | tls->interrupt_cue = ic; | |
99 | 1326 | tls->is_set = true; | |
100 | } | ||
101 | 1668 | } | |
102 | |||
103 | |||
104 | ✗ | void ClientCtx::TlsDestructor(void *data) { | |
105 | ✗ | ThreadLocalStorage *tls = static_cast<ClientCtx::ThreadLocalStorage *>(data); | |
106 | ✗ | delete tls; | |
107 | |||
108 | ✗ | assert(instance_); | |
109 | ✗ | const MutexLockGuard lock_guard(instance_->lock_tls_blocks_); | |
110 | ✗ | for (vector<ThreadLocalStorage *>::iterator | |
111 | ✗ | i = instance_->tls_blocks_.begin(), | |
112 | ✗ | iEnd = instance_->tls_blocks_.end(); | |
113 | ✗ | i != iEnd; | |
114 | ✗ | ++i) { | |
115 | ✗ | if ((*i) == tls) { | |
116 | ✗ | instance_->tls_blocks_.erase(i); | |
117 | ✗ | break; | |
118 | } | ||
119 | } | ||
120 | } | ||
121 | |||
122 | |||
123 | 1488 | void ClientCtx::Unset() { | |
124 | ThreadLocalStorage *tls = static_cast<ThreadLocalStorage *>( | ||
125 | 1488 | pthread_getspecific(thread_local_storage_)); | |
126 |
1/2✓ Branch 0 taken 1488 times.
✗ Branch 1 not taken.
|
1488 | if (tls != NULL) { |
127 | 1488 | tls->is_set = false; | |
128 | 1488 | tls->uid = -1; | |
129 | 1488 | tls->gid = -1; | |
130 | 1488 | tls->pid = -1; | |
131 | 1488 | tls->interrupt_cue = NULL; | |
132 | } | ||
133 | 1488 | } | |
134 |