Changeset 176762 in webkit


Ignore:
Timestamp:
Dec 3, 2014 4:16:38 PM (9 years ago)
Author:
andersca@apple.com
Message:

Unreviewed, rolling out r176452 and r176559.
​https://bugs.webkit.org/show_bug.cgi?id=139239

Broke iOS (Requested by andersca on #webkit).

Reverted changesets:

"Remove alignment code from IPC coders"
​https://bugs.webkit.org/show_bug.cgi?id=138963
​http://trac.webkit.org/changeset/176452

"[WK2] SecComp buildfix after r176452"
​https://bugs.webkit.org/show_bug.cgi?id=139081
​http://trac.webkit.org/changeset/176559

Patch by Commit Queue <​commit-queue@webkit.org> on 2014-12-03

Location:
trunk/Source/WebKit2
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r176753 r176762  
     12014-12-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r176452 and r176559.
     4        https://bugs.webkit.org/show_bug.cgi?id=139239
     5
     6        Broke iOS (Requested by andersca on #webkit).
     7
     8        Reverted changesets:
     9
     10        "Remove alignment code from IPC coders"
     11        https://bugs.webkit.org/show_bug.cgi?id=138963
     12        http://trac.webkit.org/changeset/176452
     13
     14        "[WK2] SecComp buildfix after r176452"
     15        https://bugs.webkit.org/show_bug.cgi?id=139081
     16        http://trac.webkit.org/changeset/176559
     17
    1182014-12-03  Tim Horton  <timothy_horton@apple.com>
    219

  • trunk/Source/WebKit2/Platform/IPC/ArgumentCoders.cpp

    r176452 r176762  
    5858    uint32_t length = string.length();
    5959    encoder << length;
    60     encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length);
     60    encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length, 1);
    6161}
    6262
    … …  
    8181    char* buffer;
    8282    CString string = CString::newUninitialized(length, buffer);
    83     if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length))
     83    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length, 1))
    8484        return false;
    8585
    … …  
    103103
    104104    if (is8Bit)
    105         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar));
     105        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar), alignof(LChar));
    106106    else
    107         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar));
     107        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar), alignof(UChar));
    108108}
    109109
    … …  
    119119    CharacterType* buffer;
    120120    String string = String::createUninitialized(length, buffer);
    121     if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType)))
     121    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType), alignof(CharacterType)))
    122122        return false;
    123123   

  • trunk/Source/WebKit2/Platform/IPC/ArgumentCoders.h

    r176452 r176762  
    4242    static void encode(ArgumentEncoder& encoder, const T& t)
    4343    {
    44         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(&t), sizeof(T));
     44        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(&t), sizeof(T), alignof(T));
    4545    }
    4646
    4747    static bool decode(ArgumentDecoder& decoder, T& t)
    4848    {
    49         return decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(&t), sizeof(T));
     49        return decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(&t), sizeof(T), alignof(T));
    5050    }
    5151};
    … …  
    179179    {
    180180        encoder << static_cast<uint64_t>(vector.size());
    181         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(vector.data()), vector.size() * sizeof(T));
     181        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(vector.data()), vector.size() * sizeof(T), alignof(T));
    182182    }
    183183   
    … …  
    199199        temp.resize(size);
    200200
    201         decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(temp.data()), size * sizeof(T));
     201        decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(temp.data()), size * sizeof(T), alignof(T));
    202202
    203203        vector.swap(temp);

  • trunk/Source/WebKit2/Platform/IPC/ArgumentDecoder.cpp

    r176452 r176762  
    5757}
    5858
     59static inline uint8_t* roundUpToAlignment(uint8_t* ptr, unsigned alignment)
     60{
     61    // Assert that the alignment is a power of 2.
     62    ASSERT(alignment && !(alignment & (alignment - 1)));
     63
     64    uintptr_t alignmentMask = alignment - 1;
     65    return reinterpret_cast<uint8_t*>((reinterpret_cast<uintptr_t>(ptr) + alignmentMask) & ~alignmentMask);
     66}
     67
    5968void ArgumentDecoder::initialize(const uint8_t* buffer, size_t bufferSize)
    6069{
    … …  
    6372    ASSERT(!(reinterpret_cast<uintptr_t>(m_buffer) % alignof(uint64_t)));
    6473
    65     m_bufferPosition = m_buffer;
     74    m_bufferPos = m_buffer;
    6675    m_bufferEnd = m_buffer + bufferSize;
    6776    memcpy(m_buffer, buffer, bufferSize);
    6877}
    6978
    70 bool ArgumentDecoder::bufferIsLargeEnoughToContain(size_t size) const
    71 {
    72     return m_buffer + size <= m_bufferEnd;
    73 }
    74 
    75 bool ArgumentDecoder::decodeFixedLengthData(uint8_t* data, size_t size)
    76 {
    77     if (!bufferIsLargeEnoughToContain(size))
    78         return false;
    79 
    80     memcpy(data, m_bufferPosition, size);
    81     m_bufferPosition += size;
     79static inline bool alignedBufferIsLargeEnoughToContain(const uint8_t* alignedPosition, const uint8_t* bufferEnd, size_t size)
     80{
     81    return bufferEnd >= alignedPosition && static_cast<size_t>(bufferEnd - alignedPosition) >= size;
     82}
     83
     84bool ArgumentDecoder::alignBufferPosition(unsigned alignment, size_t size)
     85{
     86    uint8_t* alignedPosition = roundUpToAlignment(m_bufferPos, alignment);
     87    if (!alignedBufferIsLargeEnoughToContain(alignedPosition, m_bufferEnd, size)) {
     88        // We've walked off the end of this buffer.
     89        markInvalid();
     90        return false;
     91    }
     92   
     93    m_bufferPos = alignedPosition;
     94    return true;
     95}
     96
     97bool ArgumentDecoder::bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const
     98{
     99    return alignedBufferIsLargeEnoughToContain(roundUpToAlignment(m_bufferPos, alignment), m_bufferEnd, size);
     100}
     101
     102bool ArgumentDecoder::decodeFixedLengthData(uint8_t* data, size_t size, unsigned alignment)
     103{
     104    if (!alignBufferPosition(alignment, size))
     105        return false;
     106
     107    memcpy(data, m_bufferPos, size);
     108    m_bufferPos += size;
    82109
    83110    return true;
    … …  
    90117        return false;
    91118   
    92     if (!bufferIsLargeEnoughToContain(size))
    93         return false;
    94 
    95     uint8_t* data = m_bufferPosition;
    96     m_bufferPosition += size;
     119    if (!alignBufferPosition(1, size))
     120        return false;
     121
     122    uint8_t* data = m_bufferPos;
     123    m_bufferPos += size;
    97124
    98125    dataReference = DataReference(data, size);
    … …  
    101128
    102129template<typename Type>
    103 bool ArgumentDecoder::decodeNumber(Type& value)
    104 {
    105     if (!bufferIsLargeEnoughToContain(sizeof(Type)))
    106         return false;
    107 
    108     memcpy(&value, m_bufferPosition, sizeof(Type));
    109     m_bufferPosition += sizeof(Type);
    110 
    111     return true;
     130static void decodeValueFromBuffer(Type& value, uint8_t*& bufferPosition)
     131{
     132    memcpy(&value, bufferPosition, sizeof(value));
     133    bufferPosition += sizeof(Type);
    112134}
    113135
    114136bool ArgumentDecoder::decode(bool& result)
    115137{
    116     return decodeNumber(result);
     138    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     139        return false;
     140   
     141    decodeValueFromBuffer(result, m_bufferPos);
     142    return true;
    117143}
    118144
    119145bool ArgumentDecoder::decode(uint8_t& result)
    120146{
    121     return decodeNumber(result);
     147    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     148        return false;
     149
     150    decodeValueFromBuffer(result, m_bufferPos);
     151    return true;
    122152}
    123153
    124154bool ArgumentDecoder::decode(uint16_t& result)
    125155{
    126     return decodeNumber(result);
     156    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     157        return false;
     158
     159    decodeValueFromBuffer(result, m_bufferPos);
     160    return true;
    127161}
    128162
    129163bool ArgumentDecoder::decode(uint32_t& result)
    130164{
    131     return decodeNumber(result);
     165    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     166        return false;
     167
     168    decodeValueFromBuffer(result, m_bufferPos);
     169    return true;
    132170}
    133171
    134172bool ArgumentDecoder::decode(uint64_t& result)
    135173{
    136     return decodeNumber(result);
     174    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     175        return false;
     176   
     177    decodeValueFromBuffer(result, m_bufferPos);
     178    return true;
    137179}
    138180
    139181bool ArgumentDecoder::decode(int32_t& result)
    140182{
    141     return decodeNumber(result);
     183    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     184        return false;
     185   
     186    decodeValueFromBuffer(result, m_bufferPos);
     187    return true;
    142188}
    143189
    144190bool ArgumentDecoder::decode(int64_t& result)
    145191{
    146     return decodeNumber(result);
     192    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     193        return false;
     194
     195    decodeValueFromBuffer(result, m_bufferPos);
     196    return true;
    147197}
    148198
    149199bool ArgumentDecoder::decode(float& result)
    150200{
    151     return decodeNumber(result);
     201    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     202        return false;
     203
     204    decodeValueFromBuffer(result, m_bufferPos);
     205    return true;
    152206}
    153207
    154208bool ArgumentDecoder::decode(double& result)
    155209{
    156     return decodeNumber(result);
     210    if (!alignBufferPosition(sizeof(result), sizeof(result)))
     211        return false;
     212   
     213    decodeValueFromBuffer(result, m_bufferPos);
     214    return true;
    157215}
    158216

  • trunk/Source/WebKit2/Platform/IPC/ArgumentDecoder.h

    r176452 r176762  
    4343    size_t length() const { return m_bufferEnd - m_buffer; }
    4444
    45     bool isInvalid() const { return m_bufferPosition > m_bufferEnd; }
    46     void markInvalid() { m_bufferPosition = m_bufferEnd + 1; }
     45    bool isInvalid() const { return m_bufferPos > m_bufferEnd; }
     46    void markInvalid() { m_bufferPos = m_bufferEnd + 1; }
    4747
    48     bool decodeFixedLengthData(uint8_t*, size_t);
     48    bool decodeFixedLengthData(uint8_t*, size_t, unsigned alignment);
    4949
    5050    // The data in the data reference here will only be valid for the lifetime of the ArgumentDecoder object.
    … …  
    8181            return false;
    8282
    83         return bufferIsLargeEnoughToContain(numElements * sizeof(T));
     83        return bufferIsLargeEnoughToContain(alignof(T), numElements * sizeof(T));
    8484    }
    8585
    … …  
    9797    void initialize(const uint8_t* buffer, size_t bufferSize);
    9898
    99     bool bufferIsLargeEnoughToContain(size_t) const;
    100     template <typename Type> bool decodeNumber(Type& value);
     99    bool alignBufferPosition(unsigned alignment, size_t size);
     100    bool bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const;
    101101
    102102private:
    103103    uint8_t* m_buffer;
    104     uint8_t* m_bufferPosition;
     104    uint8_t* m_bufferPos;
    105105    uint8_t* m_bufferEnd;
    106106

  • trunk/Source/WebKit2/Platform/IPC/ArgumentEncoder.cpp

    r176452 r176762  
    5858ArgumentEncoder::ArgumentEncoder()
    5959    : m_buffer(m_inlineBuffer)
     60    , m_bufferPointer(m_inlineBuffer)
    6061    , m_bufferSize(0)
    6162    , m_bufferCapacity(sizeof(m_inlineBuffer))
    … …  
    103104}
    104105
    105 uint8_t* ArgumentEncoder::grow(size_t size)
    106 {
    107     size_t position = m_bufferSize;
    108     reserve(m_bufferSize + size);
    109 
    110     m_bufferSize += size;
    111 
    112     return m_buffer + position;
    113 }
    114 
    115 void ArgumentEncoder::encodeFixedLengthData(const uint8_t* data, size_t size)
    116 {
    117     uint8_t* buffer = grow(size);
     106uint8_t* ArgumentEncoder::grow(unsigned alignment, size_t size)
     107{
     108    size_t alignedSize = roundUpToAlignment(m_bufferSize, alignment);
     109    reserve(alignedSize + size);
     110
     111    m_bufferSize = alignedSize + size;
     112    m_bufferPointer = m_buffer + alignedSize + size;
     113   
     114    return m_buffer + alignedSize;
     115}
     116
     117void ArgumentEncoder::encodeFixedLengthData(const uint8_t* data, size_t size, unsigned alignment)
     118{
     119    ASSERT(!(reinterpret_cast<uintptr_t>(data) % alignment));
     120
     121    uint8_t* buffer = grow(alignment, size);
    118122    memcpy(buffer, data, size);
    119123}
    … …  
    122126{
    123127    encode(static_cast<uint64_t>(dataReference.size()));
    124     encodeFixedLengthData(dataReference.data(), dataReference.size());
     128    encodeFixedLengthData(dataReference.data(), dataReference.size(), 1);
    125129}
    126130
    127131template<typename Type>
    128 void ArgumentEncoder::encodeNumber(Type value)
    129 {
    130     uint8_t* bufferPosition = grow(sizeof(Type));
     132static void copyValueToBuffer(Type value, uint8_t* bufferPosition)
     133{
    131134    memcpy(bufferPosition, &value, sizeof(Type));
    132135}
    133136
    134 void ArgumentEncoder::encode(bool value)
    135 {
    136     encodeNumber(value);
    137 }
    138 
    139 void ArgumentEncoder::encode(uint8_t value)
    140 {
    141     encodeNumber(value);
    142 }
    143 
    144 void ArgumentEncoder::encode(uint16_t value)
    145 {
    146     encodeNumber(value);
    147 }
    148 
    149 void ArgumentEncoder::encode(uint32_t value)
    150 {
    151     encodeNumber(value);
    152 }
    153 
    154 void ArgumentEncoder::encode(uint64_t value)
    155 {
    156     encodeNumber(value);
    157 }
    158 
    159 void ArgumentEncoder::encode(int32_t value)
    160 {
    161     encodeNumber(value);
    162 }
    163 
    164 void ArgumentEncoder::encode(int64_t value)
    165 {
    166     encodeNumber(value);
    167 }
    168 
    169 void ArgumentEncoder::encode(float value)
    170 {
    171     encodeNumber(value);
    172 }
    173 
    174 void ArgumentEncoder::encode(double value)
    175 {
    176     encodeNumber(value);
     137void ArgumentEncoder::encode(bool n)
     138{
     139    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     140    copyValueToBuffer(n, buffer);
     141}
     142
     143void ArgumentEncoder::encode(uint8_t n)
     144{
     145    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     146    copyValueToBuffer(n, buffer);
     147}
     148
     149void ArgumentEncoder::encode(uint16_t n)
     150{
     151    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     152    copyValueToBuffer(n, buffer);
     153}
     154
     155void ArgumentEncoder::encode(uint32_t n)
     156{
     157    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     158    copyValueToBuffer(n, buffer);
     159}
     160
     161void ArgumentEncoder::encode(uint64_t n)
     162{
     163    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     164    copyValueToBuffer(n, buffer);
     165}
     166
     167void ArgumentEncoder::encode(int32_t n)
     168{
     169    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     170    copyValueToBuffer(n, buffer);
     171}
     172
     173void ArgumentEncoder::encode(int64_t n)
     174{
     175    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     176    copyValueToBuffer(n, buffer);
     177}
     178
     179void ArgumentEncoder::encode(float n)
     180{
     181    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     182    copyValueToBuffer(n, buffer);
     183}
     184
     185void ArgumentEncoder::encode(double n)
     186{
     187    uint8_t* buffer = grow(sizeof(n), sizeof(n));
     188    copyValueToBuffer(n, buffer);
    177189}
    178190

  • trunk/Source/WebKit2/Platform/IPC/ArgumentEncoder.h

    r176452 r176762  
    4242    virtual ~ArgumentEncoder();
    4343
    44     void encodeFixedLengthData(const uint8_t*, size_t);
     44    void encodeFixedLengthData(const uint8_t*, size_t, unsigned alignment);
    4545    void encodeVariableLengthByteArray(const DataReference&);
    4646
    … …  
    6363    }
    6464
    65     const uint8_t* buffer() const { return m_buffer; }
     65    uint8_t* buffer() const { return m_buffer; }
    6666    size_t bufferSize() const { return m_bufferSize; }
    6767
    … …  
    6969    Vector<Attachment> releaseAttachments();
    7070    void reserve(size_t);
    71 
    72 protected:
    73     uint8_t* mutableBuffer() { return m_buffer; }
    7471
    7572private:
    … …  
    8380    void encode(float);
    8481    void encode(double);
    85     template<typename Type> void encodeNumber(Type);
    8682
    87     uint8_t* grow(size_t);
     83    uint8_t* grow(unsigned alignment, size_t size);
    8884
    8985    uint8_t m_inlineBuffer[512];
     86
    9087    uint8_t* m_buffer;
    91 
     88    uint8_t* m_bufferPointer;
     89   
    9290    size_t m_bufferSize;
    9391    size_t m_bufferCapacity;

  • trunk/Source/WebKit2/Platform/IPC/DataReference.cpp

    r176452 r176762  
    5252    while (position < bufferSize) {
    5353        unsigned bytesToWrite = m_buffer->getSomeData(partialData, position);
    54         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(partialData), bytesToWrite);
     54        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(partialData), bytesToWrite, 1);
    5555        position += bytesToWrite;
    5656    }

  • trunk/Source/WebKit2/Platform/IPC/MessageEncoder.cpp

    r176452 r176762  
    5252{
    5353    if (isSyncMessage)
    54         *mutableBuffer() |= SyncMessage;
     54        *buffer() |= SyncMessage;
    5555    else
    56         *mutableBuffer() &= ~SyncMessage;
     56        *buffer() &= ~SyncMessage;
    5757}
    5858
    … …  
    6060{
    6161    if (shouldDispatchMessageWhenWaitingForSyncReply)
    62         *mutableBuffer() |= DispatchMessageWhenWaitingForSyncReply;
     62        *buffer() |= DispatchMessageWhenWaitingForSyncReply;
    6363    else
    64         *mutableBuffer() &= ~DispatchMessageWhenWaitingForSyncReply;
     64        *buffer() &= ~DispatchMessageWhenWaitingForSyncReply;
    6565}
    6666

  • trunk/Source/WebKit2/Platform/IPC/mac/ConnectionMac.mm

    r176452 r176762  
    328328            mach_msg_descriptor_t* descriptor = reinterpret_cast<mach_msg_descriptor_t*>(descriptorData);
    329329
    330             descriptor->out_of_line.address = const_cast<uint8_t*>(encoder->buffer());
     330            descriptor->out_of_line.address = encoder->buffer();
    331331            descriptor->out_of_line.size = encoder->bufferSize();
    332332            descriptor->out_of_line.copy = MACH_MSG_VIRTUAL_COPY;

  • trunk/Source/WebKit2/Platform/IPC/unix/ConnectionUnix.cpp

    r176452 r176762  
    515515
    516516    if (!messageInfo.isMessageBodyIsOutOfLine() && encoder->bufferSize()) {
    517         iov[iovLength].iov_base = reinterpret_cast<void*>(const_cast<uint8_t*>(encoder->buffer()));
     517        iov[iovLength].iov_base = reinterpret_cast<void*>(encoder->buffer());
    518518        iov[iovLength].iov_len = encoder->bufferSize();
    519519        ++iovLength;

  • trunk/Source/WebKit2/Shared/linux/SeccompFilters/SeccompBroker.cpp

    r176559 r176762  
    206206    m_socketLock.lock();
    207207
    208     if (sendMessage(m_socket, reinterpret_cast<void*>(const_cast<uint8_t*>(encoder->buffer())), encoder->bufferSize()) < 0)
     208    if (sendMessage(m_socket, encoder->buffer(), encoder->bufferSize()) < 0)
    209209        CRASH();
    210210
    … …  
    341341
    342342        // The client is down, the broker should go away.
    343         if (sendMessage(socket, reinterpret_cast<void*>(const_cast<uint8_t*>(encoder->buffer())), encoder->bufferSize(), fd) < 0)
     343        if (sendMessage(socket, encoder->buffer(), encoder->bufferSize(), fd) < 0)
    344344            exit(EXIT_SUCCESS);
    345345    }
Note: See TracChangeset for help on using the changeset viewer.