Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset fd210de in mainline


Ignore:
Timestamp:
2009-08-13T17:26:25Z (11 years ago)
Author:
Lenka Trochtova <trochtova.lenka@…>
Branches:
master
Children:
8344d0a
Parents:
75a2dc08 (diff), 64cbf94 (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:

dd branch synchronized with head

Files:
1 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/ipc/event_types.h

    r75a2dc08 rfd210de  
    3939        EVENT_KLOG = 0,
    4040        EVENT_KCONSOLE,
    41         EVENT_WAIT,
    4241        EVENT_END
    4342} event_type_t;
    44 
    45 typedef enum wait_type {
    46         TASK_CREATE = 0,
    47         TASK_DESTROY
    48 } wait_type_t;
    4943
    5044#endif
  • kernel/generic/src/proc/task.c

    r75a2dc08 rfd210de  
    197197        interrupts_restore(ipl);
    198198       
    199         /*
    200          * Notify about task creation.
    201          */
    202         if (event_is_subscribed(EVENT_WAIT))
    203                 event_notify_3(EVENT_WAIT, TASK_CREATE, LOWER32(ta->taskid),
    204                     UPPER32(ta->taskid));
    205        
    206199        return ta;
    207200}
     
    235228        if (atomic_predec(&t->as->refcount) == 0)
    236229                as_destroy(t->as);
    237        
    238         /*
    239          * Notify about task destruction.
    240          */
    241         if (event_is_subscribed(EVENT_WAIT))
    242                 event_notify_3(EVENT_WAIT, TASK_DESTROY, LOWER32(t->taskid),
    243                     UPPER32(t->taskid));
    244230       
    245231        free(t);
  • kernel/generic/src/udebug/udebug.c

    r75a2dc08 rfd210de  
    182182
    183183        if (THREAD->udebug.active && THREAD->udebug.go == false) {
    184                 TASK->udebug.begin_call = NULL;
    185184                mutex_unlock(&THREAD->udebug.lock);
    186185                mutex_unlock(&TASK->udebug.lock);
  • tools/config.py

    r75a2dc08 rfd210de  
    3434import os
    3535import re
    36 import commands
     36import time
     37import subprocess
    3738import xtui
    3839
     
    225226        "Create output configuration"
    226227       
    227         revision = commands.getoutput('bzr version-info --custom --template="{revision_id}" 2> /dev/null')
    228         timestamp = commands.getoutput('date "+%Y-%m-%d %H:%M:%S"')
     228        timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
     229        version = subprocess.Popen(['bzr', 'version-info', '--custom', '--template={clean}:{revno}:{revision_id}'], stdout = subprocess.PIPE).communicate()[0].split(':')
     230       
     231        if (len(version) == 3):
     232                revision = version[1]
     233                if (version[0] != 1):
     234                        revision += 'M'
     235                revision += ' (%s)' % version[2]
     236        else:
     237                revision = None
    229238       
    230239        outmk = file(mkname, 'w')
     
    266275                        outdf.write(' -D%s=%s -D%s_%s' % (varname, default, varname, default))
    267276       
    268         outmk.write('REVISION = %s\n' % revision)
     277        if (revision is not None):
     278                outmk.write('REVISION = %s\n' % revision)
     279                outmc.write('#define REVISION %s\n' % revision)
     280                outdf.write(' "-DREVISION=%s"' % revision)
     281       
    269282        outmk.write('TIMESTAMP = %s\n' % timestamp)
    270        
    271         outmc.write('#define REVISION %s\n' % revision)
    272283        outmc.write('#define TIMESTAMP %s\n' % timestamp)
    273        
    274         outdf.write(' "-DREVISION=%s" "-DTIMESTAMP=%s"\n' % (revision, timestamp))
     284        outdf.write(' "-DTIMESTAMP=%s"\n' % timestamp)
    275285       
    276286        outmk.close()
  • uspace/lib/libc/generic/vfs/vfs.c

    r75a2dc08 rfd210de  
    122122        int res;
    123123        ipcarg_t rc;
     124        ipcarg_t rc_orig;
    124125        aid_t req;
    125126        dev_handle_t dev_handle;
     
    141142        rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    142143        if (rc != EOK) {
    143                 async_wait_for(req, NULL);
     144                async_wait_for(req, &rc_orig);
    144145                async_serialize_end();
    145146                futex_up(&vfs_phone_futex);
    146147                free(mpa);
    147                 return (int) rc;
     148                if (rc_orig == EOK)
     149                        return (int) rc;
     150                else
     151                        return (int) rc_orig;
    148152        }
    149153       
    150154        rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
    151155        if (rc != EOK) {
    152                 async_wait_for(req, NULL);
     156                async_wait_for(req, &rc_orig);
    153157                async_serialize_end();
    154158                futex_up(&vfs_phone_futex);
    155159                free(mpa);
    156                 return (int) rc;
     160                if (rc_orig == EOK)
     161                        return (int) rc;
     162                else
     163                        return (int) rc_orig;
    157164        }
    158165
    159166        rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    160167        if (rc != EOK) {
    161                 async_wait_for(req, NULL);
     168                async_wait_for(req, &rc_orig);
    162169                async_serialize_end();
    163170                futex_up(&vfs_phone_futex);
    164171                free(mpa);
    165                 return (int) rc;
     172                if (rc_orig == EOK)
     173                        return (int) rc;
     174                else
     175                        return (int) rc_orig;
    166176        }
    167177
     
    169179        rc = async_req_0_0(vfs_phone, IPC_M_PING);
    170180        if (rc != EOK) {
    171                 async_wait_for(req, NULL);
     181                async_wait_for(req, &rc_orig);
    172182                async_serialize_end();
    173183                futex_up(&vfs_phone_futex);
    174184                free(mpa);
    175                 return (int) rc;
     185                if (rc_orig == EOK)
     186                        return (int) rc;
     187                else
     188                        return (int) rc_orig;
    176189        }
    177190       
     
    202215        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    203216        if (rc != EOK) {
    204                 async_wait_for(req, NULL);
     217                ipcarg_t rc_orig;
     218       
     219                async_wait_for(req, &rc_orig);
    205220                async_serialize_end();
    206221                futex_up(&vfs_phone_futex);
    207222                free(pa);
    208                 return (int) rc;
     223                if (rc_orig == EOK)
     224                        return (int) rc;
     225                else
     226                        return (int) rc_orig;
    209227        }
    210228        async_wait_for(req, &rc);
     
    240258       
    241259        if (rc != EOK)
    242             return (int) rc;
     260                return (int) rc;
    243261       
    244262        return (int) IPC_GET_ARG1(answer);
     
    274292        rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
    275293        if (rc != EOK) {
    276                 async_wait_for(req, NULL);
    277                 async_serialize_end();
    278                 futex_up(&vfs_phone_futex);
    279                 return (ssize_t) rc;
     294                ipcarg_t rc_orig;
     295       
     296                async_wait_for(req, &rc_orig);
     297                async_serialize_end();
     298                futex_up(&vfs_phone_futex);
     299                if (rc_orig == EOK)
     300                        return (ssize_t) rc;
     301                else
     302                        return (ssize_t) rc_orig;
    280303        }
    281304        async_wait_for(req, &rc);
     
    301324        rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
    302325        if (rc != EOK) {
    303                 async_wait_for(req, NULL);
    304                 async_serialize_end();
    305                 futex_up(&vfs_phone_futex);
    306                 return (ssize_t) rc;
     326                ipcarg_t rc_orig;
     327       
     328                async_wait_for(req, &rc_orig);
     329                async_serialize_end();
     330                futex_up(&vfs_phone_futex);
     331                if (rc_orig == EOK)
     332                        return (ssize_t) rc;
     333                else
     334                        return (ssize_t) rc_orig;
    307335        }
    308336        async_wait_for(req, &rc);
     
    376404        rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
    377405        if (rc != EOK) {
    378                 async_wait_for(req, NULL);
    379                 async_serialize_end();
    380                 futex_up(&vfs_phone_futex);
    381                 return (ssize_t) rc;
     406                ipcarg_t rc_orig;
     407               
     408                async_wait_for(req, &rc_orig);
     409                async_serialize_end();
     410                futex_up(&vfs_phone_futex);
     411                if (rc_orig == EOK)
     412                        return (ssize_t) rc;
     413                else
     414                        return (ssize_t) rc_orig;
    382415        }
    383416        async_wait_for(req, &rc);
     
    391424{
    392425        ipcarg_t rc;
     426        ipcarg_t rc_orig;
    393427        aid_t req;
    394428       
     
    405439        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    406440        if (rc != EOK) {
    407                 async_wait_for(req, NULL);
     441                async_wait_for(req, &rc_orig);
    408442                async_serialize_end();
    409443                futex_up(&vfs_phone_futex);
    410444                free(pa);
    411                 return (int) rc;
     445                if (rc_orig == EOK)
     446                        return (int) rc;
     447                else
     448                        return (int) rc_orig;
    412449        }
    413450        rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
    414451        if (rc != EOK) {
    415                 async_wait_for(req, NULL);
     452                async_wait_for(req, &rc_orig);
    416453                async_serialize_end();
    417454                futex_up(&vfs_phone_futex);
    418455                free(pa);
    419                 return (int) rc;
     456                if (rc_orig == EOK)
     457                        return (int) rc;
     458                else
     459                        return (int) rc_orig;
    420460        }
    421461        async_wait_for(req, &rc);
     
    476516        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    477517        if (rc != EOK) {
    478                 async_wait_for(req, NULL);
     518                ipcarg_t rc_orig;
     519       
     520                async_wait_for(req, &rc_orig);
    479521                async_serialize_end();
    480522                futex_up(&vfs_phone_futex);
    481523                free(pa);
    482                 return (int) rc;
     524                if (rc_orig == EOK)
     525                        return (int) rc;
     526                else
     527                        return (int) rc_orig;
    483528        }
    484529        async_wait_for(req, &rc);
     
    506551        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    507552        if (rc != EOK) {
    508                 async_wait_for(req, NULL);
     553                ipcarg_t rc_orig;
     554
     555                async_wait_for(req, &rc_orig);
    509556                async_serialize_end();
    510557                futex_up(&vfs_phone_futex);
    511558                free(pa);
    512                 return (int) rc;
     559                if (rc_orig == EOK)
     560                        return (int) rc;
     561                else
     562                        return (int) rc_orig;
    513563        }
    514564        async_wait_for(req, &rc);
     
    532582{
    533583        ipcarg_t rc;
     584        ipcarg_t rc_orig;
    534585        aid_t req;
    535586       
     
    553604        rc = ipc_data_write_start(vfs_phone, olda, olda_size);
    554605        if (rc != EOK) {
    555                 async_wait_for(req, NULL);
     606                async_wait_for(req, &rc_orig);
    556607                async_serialize_end();
    557608                futex_up(&vfs_phone_futex);
    558609                free(olda);
    559610                free(newa);
    560                 return (int) rc;
     611                if (rc_orig == EOK)
     612                        return (int) rc;
     613                else
     614                        return (int) rc_orig;
    561615        }
    562616        rc = ipc_data_write_start(vfs_phone, newa, newa_size);
    563617        if (rc != EOK) {
    564                 async_wait_for(req, NULL);
     618                async_wait_for(req, &rc_orig);
    565619                async_serialize_end();
    566620                futex_up(&vfs_phone_futex);
    567621                free(olda);
    568622                free(newa);
    569                 return (int) rc;
     623                if (rc_orig == EOK)
     624                        return (int) rc;
     625                else
     626                        return (int) rc_orig;
    570627        }
    571628        async_wait_for(req, &rc);
  • uspace/srv/fs/fat/fat_fat.c

    r75a2dc08 rfd210de  
    451451}
    452452
     453void
     454fat_zero_cluster(struct fat_bs *bs, dev_handle_t dev_handle, fat_cluster_t c)
     455{
     456        int i;
     457        block_t *b;
     458        unsigned bps;
     459
     460        bps = uint16_t_le2host(bs->bps);
     461       
     462        for (i = 0; i < bs->spc; i++) {
     463                b = _fat_block_get(bs, dev_handle, c, i, BLOCK_FLAGS_NOREAD);
     464                memset(b->data, 0, bps);
     465                b->dirty = true;
     466                block_put(b);
     467        }
     468}
     469
    453470/**
    454471 * @}
  • uspace/srv/fs/fat/fat_fat.h

    r75a2dc08 rfd210de  
    8484extern void fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
    8585    off_t);
     86extern void fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
    8687
    8788#endif
  • uspace/srv/fs/fat/fat_ops.c

    r75a2dc08 rfd210de  
    332332        /* idxp->lock held */
    333333        if (flags & L_DIRECTORY) {
    334                 int i;
    335                 block_t *b;
    336 
    337                 /*
    338                  * Populate the new cluster with unused dentries.
    339                  */
    340                 for (i = 0; i < bs->spc; i++) {
    341                         b = _fat_block_get(bs, dev_handle, mcl, i,
    342                             BLOCK_FLAGS_NOREAD);
    343                         /* mark all dentries as never-used */
    344                         memset(b->data, 0, bps);
    345                         b->dirty = false;
    346                         block_put(b);
    347                 }
     334                /* Populate the new cluster with unused dentries. */
     335                fat_zero_cluster(bs, dev_handle, mcl);
    348336                nodep->type = FAT_DIRECTORY;
    349337                nodep->firstc = mcl;
     
    462450         * We need to grow the parent in order to create a new unused dentry.
    463451         */
    464         if (parentp->idx->pfc == FAT_CLST_ROOT) {
     452        if (parentp->firstc == FAT_CLST_ROOT) {
    465453                /* Can't grow the root directory. */
    466454                fibril_mutex_unlock(&parentp->idx->lock);
     
    472460                return rc;
    473461        }
     462        fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
    474463        fat_append_clusters(bs, parentp, mcl);
    475         b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
     464        parentp->size += bps * bs->spc;
     465        parentp->dirty = true;          /* need to sync node */
     466        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
    476467        d = (fat_dentry_t *)b->data;
    477         /*
    478          * Clear all dentries in the block except for the first one (the first
    479          * dentry will be cleared in the next step).
    480          */
    481         memset(d + 1, 0, bps - sizeof(fat_dentry_t));
    482468
    483469hit:
  • uspace/srv/ns/task.h

    r75a2dc08 rfd210de  
    3535
    3636#include <ipc/ipc.h>
    37 #include <event.h>
    3837
    3938extern int task_init(void);
    4039extern void process_pending_wait(void);
    4140
    42 extern void wait_notification(wait_type_t et, task_id_t id);
    4341extern void wait_for_task(task_id_t id, ipc_call_t *call, ipc_callid_t callid);
    4442
  • uspace/srv/vfs/vfs_node.c

    r75a2dc08 rfd210de  
    188188        }
    189189
    190         assert(node->size == result->size);
     190        assert(node->size == result->size || node->type != VFS_NODE_FILE);
    191191        assert(node->lnkcnt == result->lnkcnt);
    192192        assert(node->type == result->type || result->type == VFS_NODE_UNKNOWN);
Note: See TracChangeset for help on using the changeset viewer.