libc/bionic/system_properties.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *  * Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *  * Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in
  12  *    the documentation and/or other materials provided with the
  13  *    distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  18  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  19  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  25  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <ctype.h>
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <poll.h>
  33 #include <stdatomic.h>
  34 #include <stdbool.h>
  35 #include <stddef.h>
  36 #include <stdint.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40 #include <new>
  41
  42 #include <linux/xattr.h>
  43 #include <netinet/in.h>
  44 #include <sys/mman.h>
  45 #include <sys/select.h>
  46 #include <sys/socket.h>
  47 #include <sys/stat.h>
  48 #include <sys/types.h>
  49 #include <sys/uio.h>
  50 #include <sys/un.h>
  51 #include <sys/xattr.h>
  52
  53 #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
  54 #include <sys/_system_properties.h>
  55 #include <sys/system_properties.h>
  56
  57 #include "private/ErrnoRestorer.h"
  58 #include "private/bionic_futex.h"
  59 #include "private/bionic_lock.h"
  60 #include "private/bionic_macros.h"
  61 #include "private/bionic_sdk_version.h"
  62 #include "private/libc_logging.h"
  63
  64 static constexpr int PROP_FILENAME_MAX = 1024;
  65
  66 static constexpr uint32_t PROP_AREA_MAGIC = 0x504f5250;
  67 static constexpr uint32_t PROP_AREA_VERSION = 0xfc6ed0ab;
  68
  69 static constexpr size_t PA_SIZE = 128 * 1024;
  70
  71 #define SERIAL_DIRTY(serial) ((serial)&1)
  72 #define SERIAL_VALUE_LEN(serial) ((serial) >> 24)
  73
  74 static const char property_service_socket[] = "/dev/socket/" PROP_SERVICE_NAME;
  75 static const char* kServiceVersionPropertyName = "ro.property_service.version";
  76
  77 /*
  78  * Properties are stored in a hybrid trie/binary tree structure.
  79  * Each property's name is delimited at '.' characters, and the tokens are put
  80  * into a trie structure.  Siblings at each level of the trie are stored in a
  81  * binary tree.  For instance, "ro.secure"="1" could be stored as follows:
  82  *
  83  * +-----+   children    +----+   children    +--------+
  84  * |     |-------------->| ro |-------------->| secure |
  85  * +-----+               +----+               +--------+
  86  *                       /    \                /   |
  87  *                 left /      \ right   left /    |  prop   +===========+
  88  *                     v        v            v     +-------->| ro.secure |
  89  *                  +-----+   +-----+     +-----+            +-----------+
  90  *                  | net |   | sys |     | com |            |     1     |
  91  *                  +-----+   +-----+     +-----+            +===========+
  92  */
  93
  94 // Represents a node in the trie.
  95 struct prop_bt {
  96   uint32_t namelen;
  97
  98   // The property trie is updated only by the init process (single threaded) which provides
  99   // property service. And it can be read by multiple threads at the same time.
 100   // As the property trie is not protected by locks, we use atomic_uint_least32_t types for the
 101   // left, right, children "pointers" in the trie node. To make sure readers who see the
 102   // change of "pointers" can also notice the change of prop_bt structure contents pointed by
 103   // the "pointers", we always use release-consume ordering pair when accessing these "pointers".
 104
 105   // prop "points" to prop_info structure if there is a propery associated with the trie node.
 106   // Its situation is similar to the left, right, children "pointers". So we use
 107   // atomic_uint_least32_t and release-consume ordering to protect it as well.
 108
 109   // We should also avoid rereading these fields redundantly, since not
 110   // all processor implementations ensure that multiple loads from the
 111   // same field are carried out in the right order.
 112   atomic_uint_least32_t prop;
 113
 114   atomic_uint_least32_t left;
 115   atomic_uint_least32_t right;
 116
 117   atomic_uint_least32_t children;
 118
 119   char name[0];
 120
 121   prop_bt(const char* name, const uint32_t name_length) {
 122     this->namelen = name_length;
 123     memcpy(this->name, name, name_length);
 124     this->name[name_length] = '\0';
 125   }
 126
 127  private:
 128   DISALLOW_COPY_AND_ASSIGN(prop_bt);
 129 };
 130
 131 class prop_area {
 132  public:
 133   prop_area(const uint32_t magic, const uint32_t version) : magic_(magic), version_(version) {
 134     atomic_init(&serial_, 0);
 135     memset(reserved_, 0, sizeof(reserved_));
 136     // Allocate enough space for the root node.
 137     bytes_used_ = sizeof(prop_bt);
 138   }
 139
 140   const prop_info* find(const char* name);
 141   bool add(const char* name, unsigned int namelen, const char* value, unsigned int valuelen);
 142
 143   bool foreach (void (*propfn)(const prop_info* pi, void* cookie), void* cookie);
 144
 145   atomic_uint_least32_t* serial() {
 146     return &serial_;
 147   }
 148   uint32_t magic() const {
 149     return magic_;
 150   }
 151   uint32_t version() const {
 152     return version_;
 153   }
 154
 155  private:
 156   void* allocate_obj(const size_t size, uint_least32_t* const off);
 157   prop_bt* new_prop_bt(const char* name, uint32_t namelen, uint_least32_t* const off);
 158   prop_info* new_prop_info(const char* name, uint32_t namelen, const char* value, uint32_t valuelen,
 159                            uint_least32_t* const off);
 160   void* to_prop_obj(uint_least32_t off);
 161   prop_bt* to_prop_bt(atomic_uint_least32_t* off_p);
 162   prop_info* to_prop_info(atomic_uint_least32_t* off_p);
 163
 164   prop_bt* root_node();
 165
 166   prop_bt* find_prop_bt(prop_bt* const bt, const char* name, uint32_t namelen, bool alloc_if_needed);
 167
 168   const prop_info* find_property(prop_bt* const trie, const char* name, uint32_t namelen,
 169                                  const char* value, uint32_t valuelen, bool alloc_if_needed);
 170
 171   bool foreach_property(prop_bt* const trie, void (*propfn)(const prop_info* pi, void* cookie),
 172                         void* cookie);
 173
 174   uint32_t bytes_used_;
 175   atomic_uint_least32_t serial_;
 176   uint32_t magic_;
 177   uint32_t version_;
 178   uint32_t reserved_[28];
 179   char data_[0];
 180
 181   DISALLOW_COPY_AND_ASSIGN(prop_area);
 182 };
 183
 184 struct prop_info {
 185   atomic_uint_least32_t serial;
 186   // we need to keep this buffer around because the property
 187   // value can be modified whereas name is constant.
 188   char value[PROP_VALUE_MAX];
 189   char name[0];
 190
 191   prop_info(const char* name, uint32_t namelen, const char* value, uint32_t valuelen) {
 192     memcpy(this->name, name, namelen);
 193     this->name[namelen] = '\0';
 194     atomic_init(&this->serial, valuelen << 24);
 195     memcpy(this->value, value, valuelen);
 196     this->value[valuelen] = '\0';
 197   }
 198
 199  private:
 200   DISALLOW_IMPLICIT_CONSTRUCTORS(prop_info);
 201 };
 202
 203 struct find_nth_cookie {
 204   uint32_t count;
 205   const uint32_t n;
 206   const prop_info* pi;
 207
 208   explicit find_nth_cookie(uint32_t n) : count(0), n(n), pi(nullptr) {
 209   }
 210 };
 211
 212 // This is public because it was exposed in the NDK. As of 2017-01, ~60 apps reference this symbol.
 213 prop_area* __system_property_area__ = nullptr;
 214
 215 static char property_filename[PROP_FILENAME_MAX] = PROP_FILENAME;
 216 static size_t pa_data_size;
 217 static size_t pa_size;
 218 static bool initialized = false;
 219
 220 static prop_area* map_prop_area_rw(const char* filename, const char* context,
 221                                    bool* fsetxattr_failed) {
 222   /* dev is a tmpfs that we can use to carve a shared workspace
 223    * out of, so let's do that...
 224    */
 225   const int fd = open(filename, O_RDWR | O_CREAT | O_NOFOLLOW | O_CLOEXEC | O_EXCL, 0444);
 226
 227   if (fd < 0) {
 228     if (errno == EACCES) {
 229       /* for consistency with the case where the process has already
 230        * mapped the page in and segfaults when trying to write to it
 231        */
 232       abort();
 233     }
 234     return nullptr;
 235   }
 236
 237   if (context) {
 238     if (fsetxattr(fd, XATTR_NAME_SELINUX, context, strlen(context) + 1, 0) != 0) {
 239       __libc_format_log(ANDROID_LOG_ERROR, "libc",
 240                         "fsetxattr failed to set context (%s) for \"%s\"", context, filename);
 241       /*
 242        * fsetxattr() will fail during system properties tests due to selinux policy.
 243        * We do not want to create a custom policy for the tester, so we will continue in
 244        * this function but set a flag that an error has occurred.
 245        * Init, which is the only daemon that should ever call this function will abort
 246        * when this error occurs.
 247        * Otherwise, the tester will ignore it and continue, albeit without any selinux
 248        * property separation.
 249        */
 250       if (fsetxattr_failed) {
 251         *fsetxattr_failed = true;
 252       }
 253     }
 254   }
 255
 256   if (ftruncate(fd, PA_SIZE) < 0) {
 257     close(fd);
 258     return nullptr;
 259   }
 260
 261   pa_size = PA_SIZE;
 262   pa_data_size = pa_size - sizeof(prop_area);
 263
 264   void* const memory_area = mmap(nullptr, pa_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 265   if (memory_area == MAP_FAILED) {
 266     close(fd);
 267     return nullptr;
 268   }
 269
 270   prop_area* pa = new (memory_area) prop_area(PROP_AREA_MAGIC, PROP_AREA_VERSION);
 271
 272   close(fd);
 273   return pa;
 274 }
 275
 276 static prop_area* map_fd_ro(const int fd) {
 277   struct stat fd_stat;
 278   if (fstat(fd, &fd_stat) < 0) {
 279     return nullptr;
 280   }
 281
 282   if ((fd_stat.st_uid != 0) || (fd_stat.st_gid != 0) ||
 283       ((fd_stat.st_mode & (S_IWGRP | S_IWOTH)) != 0) ||
 284       (fd_stat.st_size < static_cast<off_t>(sizeof(prop_area)))) {
 285     return nullptr;
 286   }
 287
 288   pa_size = fd_stat.st_size;
 289   pa_data_size = pa_size - sizeof(prop_area);
 290
 291   void* const map_result = mmap(nullptr, pa_size, PROT_READ, MAP_SHARED, fd, 0);
 292   if (map_result == MAP_FAILED) {
 293     return nullptr;
 294   }
 295
 296   prop_area* pa = reinterpret_cast<prop_area*>(map_result);
 297   if ((pa->magic() != PROP_AREA_MAGIC) || (pa->version() != PROP_AREA_VERSION)) {
 298     munmap(pa, pa_size);
 299     return nullptr;
 300   }
 301
 302   return pa;
 303 }
 304
 305 static prop_area* map_prop_area(const char* filename) {
 306   int fd = open(filename, O_CLOEXEC | O_NOFOLLOW | O_RDONLY);
 307   if (fd == -1) return nullptr;
 308
 309   prop_area* map_result = map_fd_ro(fd);
 310   close(fd);
 311
 312   return map_result;
 313 }
 314
 315 void* prop_area::allocate_obj(const size_t size, uint_least32_t* const off) {
 316   const size_t aligned = BIONIC_ALIGN(size, sizeof(uint_least32_t));
 317   if (bytes_used_ + aligned > pa_data_size) {
 318     return nullptr;
 319   }
 320
 321   *off = bytes_used_;
 322   bytes_used_ += aligned;
 323   return data_ + *off;
 324 }
 325
 326 prop_bt* prop_area::new_prop_bt(const char* name, uint32_t namelen, uint_least32_t* const off) {
 327   uint_least32_t new_offset;
 328   void* const p = allocate_obj(sizeof(prop_bt) + namelen + 1, &new_offset);
 329   if (p != nullptr) {
 330     prop_bt* bt = new (p) prop_bt(name, namelen);
 331     *off = new_offset;
 332     return bt;
 333   }
 334
 335   return nullptr;
 336 }
 337
 338 prop_info* prop_area::new_prop_info(const char* name, uint32_t namelen, const char* value,
 339                                     uint32_t valuelen, uint_least32_t* const off) {
 340   uint_least32_t new_offset;
 341   void* const p = allocate_obj(sizeof(prop_info) + namelen + 1, &new_offset);
 342   if (p != nullptr) {
 343     prop_info* info = new (p) prop_info(name, namelen, value, valuelen);
 344     *off = new_offset;
 345     return info;
 346   }
 347
 348   return nullptr;
 349 }
 350
 351 void* prop_area::to_prop_obj(uint_least32_t off) {
 352   if (off > pa_data_size) return nullptr;
 353
 354   return (data_ + off);
 355 }
 356
 357 inline prop_bt* prop_area::to_prop_bt(atomic_uint_least32_t* off_p) {
 358   uint_least32_t off = atomic_load_explicit(off_p, memory_order_consume);
 359   return reinterpret_cast<prop_bt*>(to_prop_obj(off));
 360 }
 361
 362 inline prop_info* prop_area::to_prop_info(atomic_uint_least32_t* off_p) {
 363   uint_least32_t off = atomic_load_explicit(off_p, memory_order_consume);
 364   return reinterpret_cast<prop_info*>(to_prop_obj(off));
 365 }
 366
 367 inline prop_bt* prop_area::root_node() {
 368   return reinterpret_cast<prop_bt*>(to_prop_obj(0));
 369 }
 370
 371 static int cmp_prop_name(const char* one, uint32_t one_len, const char* two, uint32_t two_len) {
 372   if (one_len < two_len)
 373     return -1;
 374   else if (one_len > two_len)
 375     return 1;
 376   else
 377     return strncmp(one, two, one_len);
 378 }
 379
 380 prop_bt* prop_area::find_prop_bt(prop_bt* const bt, const char* name, uint32_t namelen,
 381                                  bool alloc_if_needed) {
 382   prop_bt* current = bt;
 383   while (true) {
 384     if (!current) {
 385       return nullptr;
 386     }
 387
 388     const int ret = cmp_prop_name(name, namelen, current->name, current->namelen);
 389     if (ret == 0) {
 390       return current;
 391     }
 392
 393     if (ret < 0) {
 394       uint_least32_t left_offset = atomic_load_explicit(&current->left, memory_order_relaxed);
 395       if (left_offset != 0) {
 396         current = to_prop_bt(&current->left);
 397       } else {
 398         if (!alloc_if_needed) {
 399           return nullptr;
 400         }
 401
 402         uint_least32_t new_offset;
 403         prop_bt* new_bt = new_prop_bt(name, namelen, &new_offset);
 404         if (new_bt) {
 405           atomic_store_explicit(&current->left, new_offset, memory_order_release);
 406         }
 407         return new_bt;
 408       }
 409     } else {
 410       uint_least32_t right_offset = atomic_load_explicit(&current->right, memory_order_relaxed);
 411       if (right_offset != 0) {
 412         current = to_prop_bt(&current->right);
 413       } else {
 414         if (!alloc_if_needed) {
 415           return nullptr;
 416         }
 417
 418         uint_least32_t new_offset;
 419         prop_bt* new_bt = new_prop_bt(name, namelen, &new_offset);
 420         if (new_bt) {
 421           atomic_store_explicit(&current->right, new_offset, memory_order_release);
 422         }
 423         return new_bt;
 424       }
 425     }
 426   }
 427 }
 428
 429 const prop_info* prop_area::find_property(prop_bt* const trie, const char* name, uint32_t namelen,
 430                                           const char* value, uint32_t valuelen,
 431                                           bool alloc_if_needed) {
 432   if (!trie) return nullptr;
 433
 434   const char* remaining_name = name;
 435   prop_bt* current = trie;
 436   while (true) {
 437     const char* sep = strchr(remaining_name, '.');
 438     const bool want_subtree = (sep != nullptr);
 439     const uint32_t substr_size = (want_subtree) ? sep - remaining_name : strlen(remaining_name);
 440
 441     if (!substr_size) {
 442       return nullptr;
 443     }
 444
 445     prop_bt* root = nullptr;
 446     uint_least32_t children_offset = atomic_load_explicit(&current->children, memory_order_relaxed);
 447     if (children_offset != 0) {
 448       root = to_prop_bt(&current->children);
 449     } else if (alloc_if_needed) {
 450       uint_least32_t new_offset;
 451       root = new_prop_bt(remaining_name, substr_size, &new_offset);
 452       if (root) {
 453         atomic_store_explicit(&current->children, new_offset, memory_order_release);
 454       }
 455     }
 456
 457     if (!root) {
 458       return nullptr;
 459     }
 460
 461     current = find_prop_bt(root, remaining_name, substr_size, alloc_if_needed);
 462     if (!current) {
 463       return nullptr;
 464     }
 465
 466     if (!want_subtree) break;
 467
 468     remaining_name = sep + 1;
 469   }
 470
 471   uint_least32_t prop_offset = atomic_load_explicit(&current->prop, memory_order_relaxed);
 472   if (prop_offset != 0) {
 473     return to_prop_info(&current->prop);
 474   } else if (alloc_if_needed) {
 475     uint_least32_t new_offset;
 476     prop_info* new_info = new_prop_info(name, namelen, value, valuelen, &new_offset);
 477     if (new_info) {
 478       atomic_store_explicit(&current->prop, new_offset, memory_order_release);
 479     }
 480
 481     return new_info;
 482   } else {
 483     return nullptr;
 484   }
 485 }
 486
 487 class PropertyServiceConnection {
 488  public:
 489   PropertyServiceConnection() : last_error_(0) {
 490     socket_ = ::socket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
 491     if (socket_ == -1) {
 492       last_error_ = errno;
 493       return;
 494     }
 495
 496     const size_t namelen = strlen(property_service_socket);
 497     sockaddr_un addr;
 498     memset(&addr, 0, sizeof(addr));
 499     strlcpy(addr.sun_path, property_service_socket, sizeof(addr.sun_path));
 500     addr.sun_family = AF_LOCAL;
 501     socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1;
 502
 503     if (TEMP_FAILURE_RETRY(connect(socket_, reinterpret_cast<sockaddr*>(&addr), alen)) == -1) {
 504       last_error_ = errno;
 505       close(socket_);
 506       socket_ = -1;
 507     }
 508   }
 509
 510   bool IsValid() {
 511     return socket_ != -1;
 512   }
 513
 514   int GetLastError() {
 515     return last_error_;
 516   }
 517
 518   bool RecvInt32(int32_t* value) {
 519     int result = TEMP_FAILURE_RETRY(recv(socket_, value, sizeof(*value), MSG_WAITALL));
 520     return CheckSendRecvResult(result, sizeof(*value));
 521   }
 522
 523   int socket() {
 524     return socket_;
 525   }
 526
 527   ~PropertyServiceConnection() {
 528     if (socket_ != -1) {
 529       close(socket_);
 530     }
 531   }
 532
 533  private:
 534   bool CheckSendRecvResult(int result, int expected_len) {
 535     if (result == -1) {
 536       last_error_ = errno;
 537     } else if (result != expected_len) {
 538       last_error_ = -1;
 539     } else {
 540       last_error_ = 0;
 541     }
 542
 543     return last_error_ == 0;
 544   }
 545
 546   int socket_;
 547   int last_error_;
 548
 549   friend class SocketWriter;
 550 };
 551
 552 class SocketWriter {
 553  public:
 554   explicit SocketWriter(PropertyServiceConnection* connection)
 555       : connection_(connection), iov_index_(0), uint_buf_index_(0)
 556   {}
 557
 558   SocketWriter& WriteUint32(uint32_t value) {
 559     CHECK(uint_buf_index_ < kUintBufSize);
 560     CHECK(iov_index_ < kIovSize);
 561     uint32_t* ptr = uint_buf_ + uint_buf_index_;
 562     uint_buf_[uint_buf_index_++] = value;
 563     iov_[iov_index_].iov_base = ptr;
 564     iov_[iov_index_].iov_len = sizeof(*ptr);
 565     ++iov_index_;
 566     return *this;
 567   }
 568
 569   SocketWriter& WriteString(const char* value) {
 570     uint32_t valuelen = strlen(value);
 571     WriteUint32(valuelen);
 572     if (valuelen == 0) {
 573       return *this;
 574     }
 575
 576     CHECK(iov_index_ < kIovSize);
 577     iov_[iov_index_].iov_base = const_cast<char*>(value);
 578     iov_[iov_index_].iov_len = valuelen;
 579     ++iov_index_;
 580
 581     return *this;
 582   }
 583
 584   bool Send() {
 585     if (!connection_->IsValid()) {
 586       return false;
 587     }
 588
 589     if (writev(connection_->socket(), iov_, iov_index_) == -1) {
 590       connection_->last_error_ = errno;
 591       return false;
 592     }
 593
 594     iov_index_ = uint_buf_index_ = 0;
 595     return true;
 596   }
 597
 598  private:
 599   static constexpr size_t kUintBufSize = 8;
 600   static constexpr size_t kIovSize = 8;
 601
 602   PropertyServiceConnection* connection_;
 603   iovec iov_[kIovSize];
 604   size_t iov_index_;
 605   uint32_t uint_buf_[kUintBufSize];
 606   size_t uint_buf_index_;
 607
 608   DISALLOW_IMPLICIT_CONSTRUCTORS(SocketWriter);
 609 };
 610
 611 struct prop_msg {
 612   unsigned cmd;
 613   char name[PROP_NAME_MAX];
 614   char value[PROP_VALUE_MAX];
 615 };
 616
 617 static int send_prop_msg(const prop_msg* msg) {
 618   PropertyServiceConnection connection;
 619   if (!connection.IsValid()) {
 620     return connection.GetLastError();
 621   }
 622
 623   int result = -1;
 624   int s = connection.socket();
 625
 626   const int num_bytes = TEMP_FAILURE_RETRY(send(s, msg, sizeof(prop_msg), 0));
 627   if (num_bytes == sizeof(prop_msg)) {
 628     // We successfully wrote to the property server but now we
 629     // wait for the property server to finish its work.  It
 630     // acknowledges its completion by closing the socket so we
 631     // poll here (on nothing), waiting for the socket to close.
 632     // If you 'adb shell setprop foo bar' you'll see the POLLHUP
 633     // once the socket closes.  Out of paranoia we cap our poll
 634     // at 250 ms.
 635     pollfd pollfds[1];
 636     pollfds[0].fd = s;
 637     pollfds[0].events = 0;
 638     const int poll_result = TEMP_FAILURE_RETRY(poll(pollfds, 1, 250 /* ms */));
 639     if (poll_result == 1 && (pollfds[0].revents & POLLHUP) != 0) {
 640       result = 0;
 641     } else {
 642       // Ignore the timeout and treat it like a success anyway.
 643       // The init process is single-threaded and its property
 644       // service is sometimes slow to respond (perhaps it's off
 645       // starting a child process or something) and thus this
 646       // times out and the caller thinks it failed, even though
 647       // it's still getting around to it.  So we fake it here,
 648       // mostly for ctl.* properties, but we do try and wait 250
 649       // ms so callers who do read-after-write can reliably see
 650       // what they've written.  Most of the time.
 651       // TODO: fix the system properties design.
 652       __libc_format_log(ANDROID_LOG_WARN, "libc",
 653                         "Property service has timed out while trying to set \"%s\" to \"%s\"",
 654                         msg->name, msg->value);
 655       result = 0;
 656     }
 657   }
 658
 659   return result;
 660 }
 661
 662 static void find_nth_fn(const prop_info* pi, void* ptr) {
 663   find_nth_cookie* cookie = reinterpret_cast<find_nth_cookie*>(ptr);
 664
 665   if (cookie->n == cookie->count) cookie->pi = pi;
 666
 667   cookie->count++;
 668 }
 669
 670 bool prop_area::foreach_property(prop_bt* const trie,
 671                                  void (*propfn)(const prop_info* pi, void* cookie), void* cookie) {
 672   if (!trie) return false;
 673
 674   uint_least32_t left_offset = atomic_load_explicit(&trie->left, memory_order_relaxed);
 675   if (left_offset != 0) {
 676     const int err = foreach_property(to_prop_bt(&trie->left), propfn, cookie);
 677     if (err < 0) return false;
 678   }
 679   uint_least32_t prop_offset = atomic_load_explicit(&trie->prop, memory_order_relaxed);
 680   if (prop_offset != 0) {
 681     prop_info* info = to_prop_info(&trie->prop);
 682     if (!info) return false;
 683     propfn(info, cookie);
 684   }
 685   uint_least32_t children_offset = atomic_load_explicit(&trie->children, memory_order_relaxed);
 686   if (children_offset != 0) {
 687     const int err = foreach_property(to_prop_bt(&trie->children), propfn, cookie);
 688     if (err < 0) return false;
 689   }
 690   uint_least32_t right_offset = atomic_load_explicit(&trie->right, memory_order_relaxed);
 691   if (right_offset != 0) {
 692     const int err = foreach_property(to_prop_bt(&trie->right), propfn, cookie);
 693     if (err < 0) return false;
 694   }
 695
 696   return true;
 697 }
 698
 699 const prop_info* prop_area::find(const char* name) {
 700   return find_property(root_node(), name, strlen(name), nullptr, 0, false);
 701 }
 702
 703 bool prop_area::add(const char* name, unsigned int namelen, const char* value,
 704                     unsigned int valuelen) {
 705   return find_property(root_node(), name, namelen, value, valuelen, true);
 706 }
 707
 708 bool prop_area::foreach (void (*propfn)(const prop_info* pi, void* cookie), void* cookie) {
 709   return foreach_property(root_node(), propfn, cookie);
 710 }
 711
 712 class context_node {
 713  public:
 714   context_node(context_node* next, const char* context, prop_area* pa)
 715       : next(next), context_(strdup(context)), pa_(pa), no_access_(false) {
 716     lock_.init(false);
 717   }
 718   ~context_node() {
 719     unmap();
 720     free(context_);
 721   }
 722   bool open(bool access_rw, bool* fsetxattr_failed);
 723   bool check_access_and_open();
 724   void reset_access();
 725
 726   const char* context() const {
 727     return context_;
 728   }
 729   prop_area* pa() {
 730     return pa_;
 731   }
 732
 733   context_node* next;
 734
 735  private:
 736   bool check_access();
 737   void unmap();
 738
 739   Lock lock_;
 740   char* context_;
 741   prop_area* pa_;
 742   bool no_access_;
 743 };
 744
 745 struct prefix_node {
 746   prefix_node(struct prefix_node* next, const char* prefix, context_node* context)
 747       : prefix(strdup(prefix)), prefix_len(strlen(prefix)), context(context), next(next) {
 748   }
 749   ~prefix_node() {
 750     free(prefix);
 751   }
 752   char* prefix;
 753   const size_t prefix_len;
 754   context_node* context;
 755   struct prefix_node* next;
 756 };
 757
 758 template <typename List, typename... Args>
 759 static inline void list_add(List** list, Args... args) {
 760   *list = new List(*list, args...);
 761 }
 762
 763 static void list_add_after_len(prefix_node** list, const char* prefix, context_node* context) {
 764   size_t prefix_len = strlen(prefix);
 765
 766   auto next_list = list;
 767
 768   while (*next_list) {
 769     if ((*next_list)->prefix_len < prefix_len || (*next_list)->prefix[0] == '*') {
 770       list_add(next_list, prefix, context);
 771       return;
 772     }
 773     next_list = &(*next_list)->next;
 774   }
 775   list_add(next_list, prefix, context);
 776 }
 777
 778 template <typename List, typename Func>
 779 static void list_foreach(List* list, Func func) {
 780   while (list) {
 781     func(list);
 782     list = list->next;
 783   }
 784 }
 785
 786 template <typename List, typename Func>
 787 static List* list_find(List* list, Func func) {
 788   while (list) {
 789     if (func(list)) {
 790       return list;
 791     }
 792     list = list->next;
 793   }
 794   return nullptr;
 795 }
 796
 797 template <typename List>
 798 static void list_free(List** list) {
 799   while (*list) {
 800     auto old_list = *list;
 801     *list = old_list->next;
 802     delete old_list;
 803   }
 804 }
 805
 806 static prefix_node* prefixes = nullptr;
 807 static context_node* contexts = nullptr;
 808
 809 /*
 810  * pthread_mutex_lock() calls into system_properties in the case of contention.
 811  * This creates a risk of dead lock if any system_properties functions
 812  * use pthread locks after system_property initialization.
 813  *
 814  * For this reason, the below three functions use a bionic Lock and static
 815  * allocation of memory for each filename.
 816  */
 817
 818 bool context_node::open(bool access_rw, bool* fsetxattr_failed) {
 819   lock_.lock();
 820   if (pa_) {
 821     lock_.unlock();
 822     return true;
 823   }
 824
 825   char filename[PROP_FILENAME_MAX];
 826   int len = __libc_format_buffer(filename, sizeof(filename), "%s/%s", property_filename, context_);
 827   if (len < 0 || len > PROP_FILENAME_MAX) {
 828     lock_.unlock();
 829     return false;
 830   }
 831
 832   if (access_rw) {
 833     pa_ = map_prop_area_rw(filename, context_, fsetxattr_failed);
 834   } else {
 835     pa_ = map_prop_area(filename);
 836   }
 837   lock_.unlock();
 838   return pa_;
 839 }
 840
 841 bool context_node::check_access_and_open() {
 842   if (!pa_ && !no_access_) {
 843     if (!check_access() || !open(false, nullptr)) {
 844       no_access_ = true;
 845     }
 846   }
 847   return pa_;
 848 }
 849
 850 void context_node::reset_access() {
 851   if (!check_access()) {
 852     unmap();
 853     no_access_ = true;
 854   } else {
 855     no_access_ = false;
 856   }
 857 }
 858
 859 bool context_node::check_access() {
 860   char filename[PROP_FILENAME_MAX];
 861   int len = __libc_format_buffer(filename, sizeof(filename), "%s/%s", property_filename, context_);
 862   if (len < 0 || len > PROP_FILENAME_MAX) {
 863     return false;
 864   }
 865
 866   return access(filename, R_OK) == 0;
 867 }
 868
 869 void context_node::unmap() {
 870   if (!pa_) {
 871     return;
 872   }
 873
 874   munmap(pa_, pa_size);
 875   if (pa_ == __system_property_area__) {
 876     __system_property_area__ = nullptr;
 877   }
 878   pa_ = nullptr;
 879 }
 880
 881 static bool map_system_property_area(bool access_rw, bool* fsetxattr_failed) {
 882   char filename[PROP_FILENAME_MAX];
 883   int len =
 884       __libc_format_buffer(filename, sizeof(filename), "%s/properties_serial", property_filename);
 885   if (len < 0 || len > PROP_FILENAME_MAX) {
 886     __system_property_area__ = nullptr;
 887     return false;
 888   }
 889
 890   if (access_rw) {
 891     __system_property_area__ =
 892         map_prop_area_rw(filename, "u:object_r:properties_serial:s0", fsetxattr_failed);
 893   } else {
 894     __system_property_area__ = map_prop_area(filename);
 895   }
 896   return __system_property_area__;
 897 }
 898
 899 static prop_area* get_prop_area_for_name(const char* name) {
 900   auto entry = list_find(prefixes, [name](prefix_node* l) {
 901     return l->prefix[0] == '*' || !strncmp(l->prefix, name, l->prefix_len);
 902   });
 903   if (!entry) {
 904     return nullptr;
 905   }
 906
 907   auto cnode = entry->context;
 908   if (!cnode->pa()) {
 909     /*
 910      * We explicitly do not check no_access_ in this case because unlike the
 911      * case of foreach(), we want to generate an selinux audit for each
 912      * non-permitted property access in this function.
 913      */
 914     cnode->open(false, nullptr);
 915   }
 916   return cnode->pa();
 917 }
 918
 919 /*
 920  * The below two functions are duplicated from label_support.c in libselinux.
 921  * TODO: Find a location suitable for these functions such that both libc and
 922  * libselinux can share a common source file.
 923  */
 924
 925 /*
 926  * The read_spec_entries and read_spec_entry functions may be used to
 927  * replace sscanf to read entries from spec files. The file and
 928  * property services now use these.
 929  */
 930
 931 /* Read an entry from a spec file (e.g. file_contexts) */
 932 static inline int read_spec_entry(char** entry, char** ptr, int* len) {
 933   *entry = nullptr;
 934   char* tmp_buf = nullptr;
 935
 936   while (isspace(**ptr) && **ptr != '\0') (*ptr)++;
 937
 938   tmp_buf = *ptr;
 939   *len = 0;
 940
 941   while (!isspace(**ptr) && **ptr != '\0') {
 942     (*ptr)++;
 943     (*len)++;
 944   }
 945
 946   if (*len) {
 947     *entry = strndup(tmp_buf, *len);
 948     if (!*entry) return -1;
 949   }
 950
 951   return 0;
 952 }
 953
 954 /*
 955  * line_buf - Buffer containing the spec entries .
 956  * num_args - The number of spec parameter entries to process.
 957  * ...      - A 'char **spec_entry' for each parameter.
 958  * returns  - The number of items processed.
 959  *
 960  * This function calls read_spec_entry() to do the actual string processing.
 961  */
 962 static int read_spec_entries(char* line_buf, int num_args, ...) {
 963   char **spec_entry, *buf_p;
 964   int len, rc, items, entry_len = 0;
 965   va_list ap;
 966
 967   len = strlen(line_buf);
 968   if (line_buf[len - 1] == '\n')
 969     line_buf[len - 1] = '\0';
 970   else
 971     /* Handle case if line not \n terminated by bumping
 972      * the len for the check below (as the line is NUL
 973      * terminated by getline(3)) */
 974     len++;
 975
 976   buf_p = line_buf;
 977   while (isspace(*buf_p)) buf_p++;
 978
 979   /* Skip comment lines and empty lines. */
 980   if (*buf_p == '#' || *buf_p == '\0') return 0;
 981
 982   /* Process the spec file entries */
 983   va_start(ap, num_args);
 984
 985   items = 0;
 986   while (items < num_args) {
 987     spec_entry = va_arg(ap, char**);
 988
 989     if (len - 1 == buf_p - line_buf) {
 990       va_end(ap);
 991       return items;
 992     }
 993
 994     rc = read_spec_entry(spec_entry, &buf_p, &entry_len);
 995     if (rc < 0) {
 996       va_end(ap);
 997       return rc;
 998     }
 999     if (entry_len) items++;
1000   }
1001   va_end(ap);
1002   return items;
1003 }
1004
1005 static bool initialize_properties_from_file(const char* filename) {
1006   FILE* file = fopen(filename, "re");
1007   if (!file) {
1008     return false;
1009   }
1010
1011   char* buffer = nullptr;
1012   size_t line_len;
1013   char* prop_prefix = nullptr;
1014   char* context = nullptr;
1015
1016   while (getline(&buffer, &line_len, file) > 0) {
1017     int items = read_spec_entries(buffer, 2, &prop_prefix, &context);
1018     if (items <= 0) {
1019       continue;
1020     }
1021     if (items == 1) {
1022       free(prop_prefix);
1023       continue;
1024     }
1025     /*
1026      * init uses ctl.* properties as an IPC mechanism and does not write them
1027      * to a property file, therefore we do not need to create property files
1028      * to store them.
1029      */
1030     if (!strncmp(prop_prefix, "ctl.", 4)) {
1031       free(prop_prefix);
1032       free(context);
1033       continue;
1034     }
1035
1036     auto old_context =
1037         list_find(contexts, [context](context_node* l) { return !strcmp(l->context(), context); });
1038     if (old_context) {
1039       list_add_after_len(&prefixes, prop_prefix, old_context);
1040     } else {
1041       list_add(&contexts, context, nullptr);
1042       list_add_after_len(&prefixes, prop_prefix, contexts);
1043     }
1044     free(prop_prefix);
1045     free(context);
1046   }
1047
1048   free(buffer);
1049   fclose(file);
1050
1051   return true;
1052 }
1053
1054 static bool initialize_properties() {
1055   // If we do find /property_contexts, then this is being
1056   // run as part of the OTA updater on older release that had
1057   // /property_contexts - b/34370523
1058   if (initialize_properties_from_file("/property_contexts")) {
1059     return true;
1060   }
1061
1062   // Use property_contexts from /system & /vendor, fall back to those from /
1063   if (access("/system/etc/selinux/plat_property_contexts", R_OK) != -1) {
1064     if (!initialize_properties_from_file("/system/etc/selinux/plat_property_contexts")) {
1065       return false;
1066     }
1067     if (!initialize_properties_from_file("/vendor/etc/selinux/nonplat_property_contexts")) {
1068       return false;
1069     }
1070   } else {
1071     if (!initialize_properties_from_file("/plat_property_contexts")) {
1072       return false;
1073     }
1074     if (!initialize_properties_from_file("/nonplat_property_contexts")) {
1075       return false;
1076     }
1077   }
1078
1079   return true;
1080 }
1081
1082 static bool is_dir(const char* pathname) {
1083   struct stat info;
1084   if (stat(pathname, &info) == -1) {
1085     return false;
1086   }
1087   return S_ISDIR(info.st_mode);
1088 }
1089
1090 static void free_and_unmap_contexts() {
1091   list_free(&prefixes);
1092   list_free(&contexts);
1093   if (__system_property_area__) {
1094     munmap(__system_property_area__, pa_size);
1095     __system_property_area__ = nullptr;
1096   }
1097 }
1098
1099 int __system_properties_init() {
1100   // This is called from __libc_init_common, and should leave errno at 0 (http://b/37248982).
1101   ErrnoRestorer errno_restorer;
1102
1103   if (initialized) {
1104     list_foreach(contexts, [](context_node* l) { l->reset_access(); });
1105     return 0;
1106   }
1107   if (is_dir(property_filename)) {
1108     if (!initialize_properties()) {
1109       return -1;
1110     }
1111     if (!map_system_property_area(false, nullptr)) {
1112       free_and_unmap_contexts();
1113       return -1;
1114     }
1115   } else {
1116     __system_property_area__ = map_prop_area(property_filename);
1117     if (!__system_property_area__) {
1118       return -1;
1119     }
1120     list_add(&contexts, "legacy_system_prop_area", __system_property_area__);
1121     list_add_after_len(&prefixes, "*", contexts);
1122   }
1123   initialized = true;
1124   return 0;
1125 }
1126
1127 int __system_property_set_filename(const char* filename) {
1128   size_t len = strlen(filename);
1129   if (len >= sizeof(property_filename)) return -1;
1130
1131   strcpy(property_filename, filename);
1132   return 0;
1133 }
1134
1135 int __system_property_area_init() {
1136   free_and_unmap_contexts();
1137   mkdir(property_filename, S_IRWXU | S_IXGRP | S_IXOTH);
1138   if (!initialize_properties()) {
1139     return -1;
1140   }
1141   bool open_failed = false;
1142   bool fsetxattr_failed = false;
1143   list_foreach(contexts, [&fsetxattr_failed, &open_failed](context_node* l) {
1144     if (!l->open(true, &fsetxattr_failed)) {
1145       open_failed = true;
1146     }
1147   });
1148   if (open_failed || !map_system_property_area(true, &fsetxattr_failed)) {
1149     free_and_unmap_contexts();
1150     return -1;
1151   }
1152   initialized = true;
1153   return fsetxattr_failed ? -2 : 0;
1154 }
1155
1156 uint32_t __system_property_area_serial() {
1157   prop_area* pa = __system_property_area__;
1158   if (!pa) {
1159     return -1;
1160   }
1161   // Make sure this read fulfilled before __system_property_serial
1162   return atomic_load_explicit(pa->serial(), memory_order_acquire);
1163 }
1164
1165 const prop_info* __system_property_find(const char* name) {
1166   if (!__system_property_area__) {
1167     return nullptr;
1168   }
1169
1170   prop_area* pa = get_prop_area_for_name(name);
1171   if (!pa) {
1172     __libc_format_log(ANDROID_LOG_ERROR, "libc", "Access denied finding property \"%s\"", name);
1173     return nullptr;
1174   }
1175
1176   return pa->find(name);
1177 }
1178
1179 // The C11 standard doesn't allow atomic loads from const fields,
1180 // though C++11 does.  Fudge it until standards get straightened out.
1181 static inline uint_least32_t load_const_atomic(const atomic_uint_least32_t* s, memory_order mo) {
1182   atomic_uint_least32_t* non_const_s = const_cast<atomic_uint_least32_t*>(s);
1183   return atomic_load_explicit(non_const_s, mo);
1184 }
1185
1186 int __system_property_read(const prop_info* pi, char* name, char* value) {
1187   while (true) {
1188     uint32_t serial = __system_property_serial(pi);  // acquire semantics
1189     size_t len = SERIAL_VALUE_LEN(serial);
1190     memcpy(value, pi->value, len + 1);
1191     // TODO: Fix the synchronization scheme here.
1192     // There is no fully supported way to implement this kind
1193     // of synchronization in C++11, since the memcpy races with
1194     // updates to pi, and the data being accessed is not atomic.
1195     // The following fence is unintuitive, but would be the
1196     // correct one if memcpy used memory_order_relaxed atomic accesses.
1197     // In practice it seems unlikely that the generated code would
1198     // would be any different, so this should be OK.
1199     atomic_thread_fence(memory_order_acquire);
1200     if (serial == load_const_atomic(&(pi->serial), memory_order_relaxed)) {
1201       if (name != nullptr) {
1202         size_t namelen = strlcpy(name, pi->name, PROP_NAME_MAX);
1203         if (namelen >= PROP_NAME_MAX) {
1204           __libc_format_log(ANDROID_LOG_ERROR, "libc",
1205                             "The property name length for \"%s\" is >= %d;"
1206                             " please use __system_property_read_callback"
1207                             " to read this property. (the name is truncated to \"%s\")",
1208                             pi->name, PROP_NAME_MAX - 1, name);
1209         }
1210       }
1211       return len;
1212     }
1213   }
1214 }
1215
1216 void __system_property_read_callback(const prop_info* pi,
1217                                      void (*callback)(void* cookie,
1218                                                       const char* name,
1219                                                       const char* value,
1220                                                       uint32_t serial),
1221                                      void* cookie) {
1222   while (true) {
1223     uint32_t serial = __system_property_serial(pi);  // acquire semantics
1224     size_t len = SERIAL_VALUE_LEN(serial);
1225     char value_buf[len + 1];
1226
1227     memcpy(value_buf, pi->value, len);
1228     value_buf[len] = '\0';
1229
1230     // TODO: see todo in __system_property_read function
1231     atomic_thread_fence(memory_order_acquire);
1232     if (serial == load_const_atomic(&(pi->serial), memory_order_relaxed)) {
1233       callback(cookie, pi->name, value_buf, serial);
1234       return;
1235     }
1236   }
1237 }
1238
1239 int __system_property_get(const char* name, char* value) {
1240   const prop_info* pi = __system_property_find(name);
1241
1242   if (pi != 0) {
1243     return __system_property_read(pi, nullptr, value);
1244   } else {
1245     value[0] = 0;
1246     return 0;
1247   }
1248 }
1249
1250 static constexpr uint32_t kProtocolVersion1 = 1;
1251 static constexpr uint32_t kProtocolVersion2 = 2;  // current
1252
1253 static atomic_uint_least32_t g_propservice_protocol_version = 0;
1254
1255 static void detect_protocol_version() {
1256   char value[PROP_VALUE_MAX];
1257   if (__system_property_get(kServiceVersionPropertyName, value) == 0) {
1258     g_propservice_protocol_version = kProtocolVersion1;
1259     __libc_format_log(ANDROID_LOG_WARN, "libc",
1260                       "Using old property service protocol (\"%s\" is not set)",
1261                       kServiceVersionPropertyName);
1262   } else {
1263     uint32_t version = static_cast<uint32_t>(atoll(value));
1264     if (version >= kProtocolVersion2) {
1265       g_propservice_protocol_version = kProtocolVersion2;
1266     } else {
1267       __libc_format_log(ANDROID_LOG_WARN, "libc",
1268                         "Using old property service protocol (\"%s\"=\"%s\")",
1269                         kServiceVersionPropertyName, value);
1270       g_propservice_protocol_version = kProtocolVersion1;
1271     }
1272   }
1273 }
1274
1275 int __system_property_set(const char* key, const char* value) {
1276   if (key == nullptr) return -1;
1277   if (value == nullptr) value = "";
1278   if (strlen(value) >= PROP_VALUE_MAX) return -1;
1279
1280   if (g_propservice_protocol_version == 0) {
1281     detect_protocol_version();
1282   }
1283
1284   if (g_propservice_protocol_version == kProtocolVersion1) {
1285     // Old protocol does not support long names
1286     if (strlen(key) >= PROP_NAME_MAX) return -1;
1287
1288     prop_msg msg;
1289     memset(&msg, 0, sizeof msg);
1290     msg.cmd = PROP_MSG_SETPROP;
1291     strlcpy(msg.name, key, sizeof msg.name);
1292     strlcpy(msg.value, value, sizeof msg.value);
1293
1294     return send_prop_msg(&msg);
1295   } else {
1296     // Use proper protocol
1297     PropertyServiceConnection connection;
1298     if (!connection.IsValid()) {
1299       errno = connection.GetLastError();
1300       __libc_format_log(ANDROID_LOG_WARN,
1301                         "libc",
1302                         "Unable to set property \"%s\" to \"%s\": connection failed; errno=%d (%s)",
1303                         key,
1304                         value,
1305                         errno,
1306                         strerror(errno));
1307       return -1;
1308     }
1309
1310     SocketWriter writer(&connection);
1311     if (!writer.WriteUint32(PROP_MSG_SETPROP2).WriteString(key).WriteString(value).Send()) {
1312       errno = connection.GetLastError();
1313       __libc_format_log(ANDROID_LOG_WARN,
1314                         "libc",
1315                         "Unable to set property \"%s\" to \"%s\": write failed; errno=%d (%s)",
1316                         key,
1317                         value,
1318                         errno,
1319                         strerror(errno));
1320       return -1;
1321     }
1322
1323     int result = -1;
1324     if (!connection.RecvInt32(&result)) {
1325       errno = connection.GetLastError();
1326       __libc_format_log(ANDROID_LOG_WARN,
1327                         "libc",
1328                         "Unable to set property \"%s\" to \"%s\": recv failed; errno=%d (%s)",
1329                         key,
1330                         value,
1331                         errno,
1332                         strerror(errno));
1333       return -1;
1334     }
1335
1336     if (result != PROP_SUCCESS) {
1337       __libc_format_log(ANDROID_LOG_WARN,
1338                         "libc",
1339                         "Unable to set property \"%s\" to \"%s\": error code: 0x%x",
1340                         key,
1341                         value,
1342                         result);
1343       return -1;
1344     }
1345
1346     return 0;
1347   }
1348 }
1349
1350 int __system_property_update(prop_info* pi, const char* value, unsigned int len) {
1351   if (len >= PROP_VALUE_MAX) {
1352     return -1;
1353   }
1354
1355   prop_area* pa = __system_property_area__;
1356
1357   if (!pa) {
1358     return -1;
1359   }
1360
1361   uint32_t serial = atomic_load_explicit(&pi->serial, memory_order_relaxed);
1362   serial |= 1;
1363   atomic_store_explicit(&pi->serial, serial, memory_order_relaxed);
1364   // The memcpy call here also races.  Again pretend it
1365   // used memory_order_relaxed atomics, and use the analogous
1366   // counterintuitive fence.
1367   atomic_thread_fence(memory_order_release);
1368   strlcpy(pi->value, value, len + 1);
1369
1370   atomic_store_explicit(&pi->serial, (len << 24) | ((serial + 1) & 0xffffff), memory_order_release);
1371   __futex_wake(&pi->serial, INT32_MAX);
1372
1373   atomic_store_explicit(pa->serial(), atomic_load_explicit(pa->serial(), memory_order_relaxed) + 1,
1374                         memory_order_release);
1375   __futex_wake(pa->serial(), INT32_MAX);
1376
1377   return 0;
1378 }
1379
1380 int __system_property_add(const char* name, unsigned int namelen, const char* value,
1381                           unsigned int valuelen) {
1382   if (valuelen >= PROP_VALUE_MAX) {
1383     return -1;
1384   }
1385
1386   if (namelen < 1) {
1387     return -1;
1388   }
1389
1390   if (!__system_property_area__) {
1391     return -1;
1392   }
1393
1394   prop_area* pa = get_prop_area_for_name(name);
1395
1396   if (!pa) {
1397     __libc_format_log(ANDROID_LOG_ERROR, "libc", "Access denied adding property \"%s\"", name);
1398     return -1;
1399   }
1400
1401   bool ret = pa->add(name, namelen, value, valuelen);
1402   if (!ret) {
1403     return -1;
1404   }
1405
1406   // There is only a single mutator, but we want to make sure that
1407   // updates are visible to a reader waiting for the update.
1408   atomic_store_explicit(
1409       __system_property_area__->serial(),
1410       atomic_load_explicit(__system_property_area__->serial(), memory_order_relaxed) + 1,
1411       memory_order_release);
1412   __futex_wake(__system_property_area__->serial(), INT32_MAX);
1413   return 0;
1414 }
1415
1416 // Wait for non-locked serial, and retrieve it with acquire semantics.
1417 uint32_t __system_property_serial(const prop_info* pi) {
1418   uint32_t serial = load_const_atomic(&pi->serial, memory_order_acquire);
1419   while (SERIAL_DIRTY(serial)) {
1420     __futex_wait(const_cast<_Atomic(uint_least32_t)*>(&pi->serial), serial, nullptr);
1421     serial = load_const_atomic(&pi->serial, memory_order_acquire);
1422   }
1423   return serial;
1424 }
1425
1426 uint32_t __system_property_wait_any(uint32_t old_serial) {
1427   uint32_t new_serial;
1428   __system_property_wait(nullptr, old_serial, &new_serial, nullptr);
1429   return new_serial;
1430 }
1431
1432 bool __system_property_wait(const prop_info* pi,
1433                             uint32_t old_serial,
1434                             uint32_t* new_serial_ptr,
1435                             const timespec* relative_timeout) {
1436   // Are we waiting on the global serial or a specific serial?
1437   atomic_uint_least32_t* serial_ptr;
1438   if (pi == nullptr) {
1439     if (__system_property_area__ == nullptr) return -1;
1440     serial_ptr = __system_property_area__->serial();
1441   } else {
1442     serial_ptr = const_cast<atomic_uint_least32_t*>(&pi->serial);
1443   }
1444
1445   uint32_t new_serial;
1446   do {
1447     int rc;
1448     if ((rc = __futex_wait(serial_ptr, old_serial, relative_timeout)) != 0 && rc == -ETIMEDOUT) {
1449       return false;
1450     }
1451     new_serial = load_const_atomic(serial_ptr, memory_order_acquire);
1452   } while (new_serial == old_serial);
1453
1454   *new_serial_ptr = new_serial;
1455   return true;
1456 }
1457
1458 const prop_info* __system_property_find_nth(unsigned n) {
1459   if (bionic_get_application_target_sdk_version() >= __ANDROID_API_O__) {
1460     __libc_fatal(
1461         "__system_property_find_nth is not supported since Android O,"
1462         " please use __system_property_foreach instead.");
1463   }
1464
1465   find_nth_cookie cookie(n);
1466
1467   const int err = __system_property_foreach(find_nth_fn, &cookie);
1468   if (err < 0) {
1469     return nullptr;
1470   }
1471
1472   return cookie.pi;
1473 }
1474
1475 int __system_property_foreach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie) {
1476   if (!__system_property_area__) {
1477     return -1;
1478   }
1479
1480   list_foreach(contexts, [propfn, cookie](context_node* l) {
1481     if (l->check_access_and_open()) {
1482       l->pa()->foreach (propfn, cookie);
1483     }
1484   });
1485   return 0;
1486 }