Changeset 82d56184 in mainline for uspace/srv


Ignore:
Timestamp:
2011-06-01T21:05:19Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5cac9cd
Parents:
682cfceb (diff), 5d1b3aa (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/srv
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/il/ip/ip.c

    r682cfceb r82d56184  
    201201
    202202        /* Set the destination address */
    203         switch (header->version) {
     203        switch (GET_IP_HEADER_VERSION(header)) {
    204204        case IPVERSION:
    205205                addrlen = sizeof(dest_in);
    … …  
    635635
    636636        /* Process all IP options */
    637         while (next < first->header_length) {
     637        while (next < GET_IP_HEADER_LENGTH(first)) {
    638638                option = (ip_option_t *) (((uint8_t *) first) + next);
    639639                /* Skip end or noop */
    … …  
    656656        if (length % 4) {
    657657                bzero(((uint8_t *) last) + length, 4 - (length % 4));
    658                 last->header_length = length / 4 + 1;
     658                SET_IP_HEADER_LENGTH(last, (length / 4 + 1));
    659659        } else {
    660                 last->header_length = length / 4;
     660                SET_IP_HEADER_LENGTH(last, (length / 4));
    661661        }
    662662
    … …  
    706706                return rc;
    707707       
    708         header->version = IPV4;
    709         header->fragment_offset_high = 0;
     708        SET_IP_HEADER_VERSION(header, IPV4);
     709        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header, 0);
    710710        header->fragment_offset_low = 0;
    711711        header->header_checksum = 0;
    … …  
    735735                        memcpy(middle_header, last_header,
    736736                            IP_HEADER_LENGTH(last_header));
    737                         header->flags |= IPFLAG_MORE_FRAGMENTS;
     737                        SET_IP_HEADER_FLAGS(header,
     738                            (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
    738739                        middle_header->total_length =
    739740                            htons(packet_get_data_length(next));
    740                         middle_header->fragment_offset_high =
    741                             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
     741                        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
     742                            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
    742743                        middle_header->fragment_offset_low =
    743744                            IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    768769                middle_header->total_length =
    769770                    htons(packet_get_data_length(next));
    770                 middle_header->fragment_offset_high =
    771                     IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
     771                SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
     772                    IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
    772773                middle_header->fragment_offset_low =
    773774                    IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
    … …  
    785786                length += packet_get_data_length(next);
    786787                free(last_header);
    787                 header->flags |= IPFLAG_MORE_FRAGMENTS;
     788                SET_IP_HEADER_FLAGS(header,
     789                    (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
    788790        }
    789791
    … …  
    834836        new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
    835837        offset = IP_FRAGMENT_OFFSET(header) + IP_HEADER_DATA_LENGTH(header);
    836         new_header->fragment_offset_high =
    837             IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset);
     838        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(new_header,
     839            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset));
    838840        new_header->fragment_offset_low =
    839841            IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
    … …  
    865867                return NULL;
    866868        memcpy(middle, last, IP_HEADER_LENGTH(last));
    867         middle->flags |= IPFLAG_MORE_FRAGMENTS;
     869        SET_IP_HEADER_FLAGS(middle,
     870            (GET_IP_HEADER_FLAGS(middle) | IPFLAG_MORE_FRAGMENTS));
    868871        return middle;
    869872}
    … …  
    922925
    923926        /* Fragmentation forbidden? */
    924         if(header->flags & IPFLAG_DONT_FRAGMENT)
     927        if(GET_IP_HEADER_FLAGS(header) & IPFLAG_DONT_FRAGMENT)
    925928                return EPERM;
    926929
    … …  
    958961
    959962        /* Mark the first as fragmented */
    960         header->flags |= IPFLAG_MORE_FRAGMENTS;
     963        SET_IP_HEADER_FLAGS(header,
     964            (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
    961965
    962966        /* Create middle fragments */
    … …  
    13191323        int rc;
    13201324
    1321         if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
     1325        if ((GET_IP_HEADER_FLAGS(header) & IPFLAG_MORE_FRAGMENTS) ||
    13221326            IP_FRAGMENT_OFFSET(header)) {
    13231327                // TODO fragmented
    … …  
    13251329        }
    13261330       
    1327         switch (header->version) {
     1331        switch (GET_IP_HEADER_VERSION(header)) {
    13281332        case IPVERSION:
    13291333                addrlen = sizeof(src_in);
    … …  
    14471451
    14481452        /* Set the destination address */
    1449         switch (header->version) {
     1453        switch (GET_IP_HEADER_VERSION(header)) {
    14501454        case IPVERSION:
    14511455                addrlen = sizeof(addr_in);

  • uspace/srv/net/tl/tcp/tcp.c

    r682cfceb r82d56184  
    476476        old_incoming = socket_data->next_incoming;
    477477
    478         if (header->finalize) {
     478        if (GET_TCP_HEADER_FINALIZE(header)) {
    479479                socket_data->fin_incoming = new_sequence_number +
    480480                    total_length - TCP_HEADER_LENGTH(header);
    … …  
    838838        assert(packet);
    839839
    840         if (!header->synchronize)
     840        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    841841                return tcp_release_and_return(packet, EINVAL);
    842842       
    … …  
    903903        assert(packet);
    904904
    905         if (!header->synchronize)
     905        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    906906                return tcp_release_and_return(packet, EINVAL);
    907907
    … …  
    10571057        assert(packet);
    10581058
    1059         if (!header->acknowledge)
     1059        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    10601060                return tcp_release_and_return(packet, EINVAL);
    10611061
    … …  
    11261126        assert(header);
    11271127
    1128         if (!header->acknowledge)
     1128        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    11291129                return;
    11301130
    … …  
    18331833
    18341834        /* Remember the outgoing FIN */
    1835         if (header->finalize)
     1835        if (GET_TCP_HEADER_FINALIZE(header))
    18361836                socket_data->fin_outgoing = socket_data->next_outgoing;
    18371837       
    … …  
    19521952                header->acknowledgement_number =
    19531953                    htonl(socket_data->next_incoming);
    1954                 header->acknowledge = 1;
     1954                SET_TCP_HEADER_ACKNOWLEDGE(header, 1);
    19551955        }
    19561956        header->window = htons(socket_data->window);
    … …  
    20242024        header->source_port = htons(socket->port);
    20252025        header->source_port = htons(socket_data->dest_port);
    2026         header->header_length = TCP_COMPUTE_HEADER_LENGTH(sizeof(*header));
    2027         header->synchronize = synchronize;
    2028         header->finalize = finalize;
     2026        SET_TCP_HEADER_LENGTH(header,
     2027            TCP_COMPUTE_HEADER_LENGTH(sizeof(*header)));
     2028        SET_TCP_HEADER_SYNCHRONIZE(header, synchronize);
     2029        SET_TCP_HEADER_FINALIZE(header, finalize);
    20292030}
    20302031

  • uspace/srv/net/tl/tcp/tcp_header.h

    r682cfceb r82d56184  
    4747 * @param[in] header The TCP packet header.
    4848 */
    49 #define TCP_HEADER_LENGTH(header)               ((header)->header_length * 4U)
     49#define TCP_HEADER_LENGTH(header)               (GET_TCP_HEADER_LENGTH(header) * 4U)
    5050
    5151/** Returns the TCP header length.
    … …  
    7373        uint32_t sequence_number;
    7474        uint32_t acknowledgement_number;
    75        
    76 #ifdef ARCH_IS_BIG_ENDIAN
    77         uint8_t header_length:4;
    78         uint8_t reserved1:4;
    79 #else
    80         uint8_t reserved1:4;
    81         uint8_t header_length:4;
    82 #endif
    8375
    84 #ifdef ARCH_IS_BIG_ENDIAN
    85         uint8_t reserved2:2;
    86         uint8_t urgent:1;
    87         uint8_t acknowledge:1;
    88         uint8_t push:1;
    89         uint8_t reset:1;
    90         uint8_t synchronize:1;
    91         uint8_t finalize:1;
    92 #else
    93         uint8_t finalize:1;
    94         uint8_t synchronize:1;
    95         uint8_t reset:1;
    96         uint8_t push:1;
    97         uint8_t acknowledge:1;
    98         uint8_t urgent:1;
    99         uint8_t reserved2:2;
    100 #endif
     76        uint8_t hlr; /* header length, reserved1 */
     77
     78#define GET_TCP_HEADER_LENGTH(header) \
     79        (((header)->hlr & 0xf0) >> 4)
     80#define SET_TCP_HEADER_LENGTH(header, length) \
     81        ((header)->hlr = \
     82         ((length & 0x0f) << 4) | ((header)->hlr & 0x0f))
     83
     84#define GET_TCP_HEADER_RESERVED1(header) \
     85        ((header)->hlr & 0x0f)
     86#define SET_TCP_HEADER_RESERVED1(header, reserved1) \
     87        ((header)->hlr = \
     88         (reserved1 & 0x0f) | ((header)->hlr & 0xf0))
     89
     90        /* reserved2, urgent, acknowledge, push, reset, synchronize, finalize */
     91        uint8_t ruaprsf; 
     92
     93#define GET_TCP_HEADER_RESERVED2(header) \
     94        (((header)->ruaprsf & 0xc0) >> 6)
     95#define SET_TCP_HEADER_RESERVED2(header, reserved2) \
     96        ((header)->ruaprsf = \
     97         ((reserved2 & 0x03) << 6) | ((header)->ruaprsf & 0x3f))
     98
     99#define GET_TCP_HEADER_URGENT(header) \
     100        (((header)->ruaprsf & 0x20) >> 5)
     101#define SET_TCP_HEADER_URGENT(header, urgent) \
     102        ((header)->ruaprsf = \
     103         ((urgent & 0x01) << 5) | ((header)->ruaprsf & 0xdf))
     104
     105#define GET_TCP_HEADER_ACKNOWLEDGE(header) \
     106        (((header)->ruaprsf & 0x10) >> 4)
     107#define SET_TCP_HEADER_ACKNOWLEDGE(header, acknowledge) \
     108        ((header)->ruaprsf = \
     109         ((acknowledge & 0x01) << 4) | ((header)->ruaprsf & 0xef))
     110
     111#define GET_TCP_HEADER_PUSH(header) \
     112        (((header)->ruaprsf & 0x08) >> 3)
     113#define SET_TCP_HEADER_PUSH(header, push) \
     114        ((header)->ruaprsf = \
     115         ((push & 0x01) << 3) | ((header)->ruaprsf & 0xf7))
     116
     117#define GET_TCP_HEADER_RESET(header) \
     118        (((header)->ruaprsf & 0x04) >> 2)
     119#define SET_TCP_HEADER_RESET(header, reset) \
     120        ((header)->ruaprsf = \
     121         ((reset & 0x01) << 2) | ((header)->ruaprsf & 0xfb))
     122
     123#define GET_TCP_HEADER_SYNCHRONIZE(header) \
     124        (((header)->ruaprsf & 0x02) >> 1)
     125#define SET_TCP_HEADER_SYNCHRONIZE(header, synchronize) \
     126        ((header)->ruaprsf = \
     127         ((synchronize & 0x01) << 1) | ((header)->ruaprsf & 0xfd))
     128
     129#define GET_TCP_HEADER_FINALIZE(header) \
     130        ((header)->ruaprsf & 0x01)
     131#define SET_TCP_HEADER_FINALIZE(header, finalize) \
     132        ((header)->ruaprsf = \
     133         (finalize & 0x01) | ((header)->ruaprsf & 0xfe))
    101134
    102135        uint16_t window;

  • uspace/srv/vfs/vfs.h

    r682cfceb r82d56184  
    176176    vfs_pair_t *, ...);
    177177extern int vfs_open_node_internal(vfs_lookup_res_t *);
    178 extern int vfs_close_internal(vfs_file_t *);
    179178
    180179extern bool vfs_nodes_init(void);

  • uspace/srv/vfs/vfs_file.c

    r682cfceb r82d56184  
    7979        for (i = 0; i < MAX_OPEN_FILES; i++) {
    8080                if (FILES[i]) {
    81                         (void) vfs_close_internal(FILES[i]);
    8281                        (void) vfs_fd_free(i);
    8382                }
    … …  
    108107}
    109108
     109/** Close the file in the endpoint FS server. */
     110static int vfs_file_close_remote(vfs_file_t *file)
     111{
     112        ipc_call_t answer;
     113        aid_t msg;
     114        sysarg_t rc;
     115        int phone;
     116
     117        assert(!file->refcnt);
     118
     119        phone = vfs_grab_phone(file->node->fs_handle);
     120        msg = async_send_2(phone, VFS_OUT_CLOSE, file->node->devmap_handle,
     121            file->node->index, &answer);
     122        async_wait_for(msg, &rc);
     123        vfs_release_phone(file->node->fs_handle, phone);
     124
     125        return IPC_GET_ARG1(answer);
     126}
     127
     128
    110129/** Increment reference count of VFS file structure.
    111130 *
    … …  
    125144 *                      decremented.
    126145 */
    127 static void vfs_file_delref(vfs_file_t *file)
    128 {
     146static int vfs_file_delref(vfs_file_t *file)
     147{
     148        int rc = EOK;
     149
    129150        assert(fibril_mutex_is_locked(&VFS_DATA->lock));
    130151
    131152        if (file->refcnt-- == 1) {
    132153                /*
    133                  * Lost the last reference to a file, need to drop our reference
    134                  * to the underlying VFS node.
     154                 * Lost the last reference to a file, need to close it in the
     155                 * endpoint FS and drop our reference to the underlying VFS node.
    135156                 */
     157                rc = vfs_file_close_remote(file);
    136158                vfs_node_delref(file->node);
    137159                free(file);
    138160        }
     161
     162        return rc;
    139163}
    140164
    … …  
    201225int vfs_fd_free(int fd)
    202226{
     227        int rc;
     228
    203229        if (!vfs_files_init())
    204230                return ENOMEM;
    … …  
    210236        }
    211237       
    212         vfs_file_delref(FILES[fd]);
     238        rc = vfs_file_delref(FILES[fd]);
    213239        FILES[fd] = NULL;
    214240        fibril_mutex_unlock(&VFS_DATA->lock);
    215241       
    216         return EOK;
     242        return rc;
    217243}
    218244

  • uspace/srv/vfs/vfs_ops.c

    r682cfceb r82d56184  
    717717}
    718718
    719 int vfs_close_internal(vfs_file_t *file)
    720 {
    721         /*
    722          * Lock the open file structure so that no other thread can manipulate
    723          * the same open file at a time.
    724          */
    725         fibril_mutex_lock(&file->lock);
    726        
    727         if (file->refcnt <= 1) {
    728                 /* Only close the file on the destination FS server
    729                    if there are no more file descriptors (except the
    730                    present one) pointing to this file. */
    731                
    732                 int fs_phone = vfs_grab_phone(file->node->fs_handle);
    733                
    734                 /* Make a VFS_OUT_CLOSE request at the destination FS server. */
    735                 aid_t msg;
    736                 ipc_call_t answer;
    737                 msg = async_send_2(fs_phone, VFS_OUT_CLOSE,
    738                     file->node->devmap_handle, file->node->index, &answer);
    739                
    740                 /* Wait for reply from the FS server. */
    741                 sysarg_t rc;
    742                 async_wait_for(msg, &rc);
    743                
    744                 vfs_release_phone(file->node->fs_handle, fs_phone);
    745                 fibril_mutex_unlock(&file->lock);
    746                
    747                 return IPC_GET_ARG1(answer);
    748         }
    749        
    750         fibril_mutex_unlock(&file->lock);
    751         return EOK;
    752 }
    753 
    754719void vfs_close(ipc_callid_t rid, ipc_call_t *request)
    755720{
    756721        int fd = IPC_GET_ARG1(*request);
    757        
    758         /* Lookup the file structure corresponding to the file descriptor. */
    759         vfs_file_t *file = vfs_file_get(fd);
    760         if (!file) {
    761                 async_answer_0(rid, ENOENT);
    762                 return;
    763         }
    764        
    765         int ret = vfs_close_internal(file);
    766         if (ret != EOK)
    767                 async_answer_0(rid, ret);
    768        
    769         vfs_file_put(file);
     722        int ret;
     723       
    770724        ret = vfs_fd_free(fd);
    771725        async_answer_0(rid, ret);
    … …  
    13691323        fibril_mutex_lock(&oldfile->lock);
    13701324       
    1371         /* Lookup an open file structure possibly corresponding to newfd. */
    1372         vfs_file_t *newfile = vfs_file_get(newfd);
    1373         if (newfile) {
    1374                 /* Close the originally opened file. */
    1375                 int ret = vfs_close_internal(newfile);
    1376                 if (ret != EOK) {
    1377                         fibril_mutex_unlock(&oldfile->lock);
    1378                         vfs_file_put(oldfile);
    1379                         vfs_file_put(newfile);
    1380                         async_answer_0(rid, ret);
    1381                         return;
    1382                 }
    1383                
    1384                 ret = vfs_fd_free(newfd);
    1385                 if (ret != EOK) {
    1386                         fibril_mutex_unlock(&oldfile->lock);
    1387                         vfs_file_put(oldfile);
    1388                         vfs_file_put(newfile);
    1389                         async_answer_0(rid, ret);
    1390                         return;
    1391                 }
    1392                 vfs_file_put(newfile);
    1393         }
     1325        /* Make sure newfd is closed. */
     1326        (void) vfs_fd_free(newfd);
    13941327       
    13951328        /* Assign the old file to newfd. */
Note: See TracChangeset for help on using the changeset viewer.