Changes in / [fd210de:75a2dc08] in mainline


Ignore:
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/ipc/event_types.h

    rfd210de r75a2dc08  
    3939        EVENT_KLOG = 0,
    4040        EVENT_KCONSOLE,
     41        EVENT_WAIT,
    4142        EVENT_END
    4243} event_type_t;
     44
     45typedef enum wait_type {
     46        TASK_CREATE = 0,
     47        TASK_DESTROY
     48} wait_type_t;
    4349
    4450#endif

  • kernel/generic/src/proc/task.c

    rfd210de r75a2dc08  
    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       
    199206        return ta;
    200207}
    … …  
    228235        if (atomic_predec(&t->as->refcount) == 0)
    229236                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));
    230244       
    231245        free(t);

  • kernel/generic/src/udebug/udebug.c

    rfd210de r75a2dc08  
    182182
    183183        if (THREAD->udebug.active && THREAD->udebug.go == false) {
     184                TASK->udebug.begin_call = NULL;
    184185                mutex_unlock(&THREAD->udebug.lock);
    185186                mutex_unlock(&TASK->udebug.lock);

  • tools/config.py

    rfd210de r75a2dc08  
    3434import os
    3535import re
    36 import time
    37 import subprocess
     36import commands
    3837import xtui
    3938
    … …  
    226225        "Create output configuration"
    227226       
    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
     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"')
    238229       
    239230        outmk = file(mkname, 'w')
    … …  
    275266                        outdf.write(' -D%s=%s -D%s_%s' % (varname, default, varname, default))
    276267       
    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        
     268        outmk.write('REVISION = %s\n' % revision)
    282269        outmk.write('TIMESTAMP = %s\n' % timestamp)
     270       
     271        outmc.write('#define REVISION %s\n' % revision)
    283272        outmc.write('#define TIMESTAMP %s\n' % timestamp)
    284         outdf.write(' "-DTIMESTAMP=%s"\n' % timestamp)
     273       
     274        outdf.write(' "-DREVISION=%s" "-DTIMESTAMP=%s"\n' % (revision, timestamp))
    285275       
    286276        outmk.close()

  • uspace/lib/libc/generic/vfs/vfs.c

    rfd210de r75a2dc08  
    122122        int res;
    123123        ipcarg_t rc;
    124         ipcarg_t rc_orig;
    125124        aid_t req;
    126125        dev_handle_t dev_handle;
    … …  
    142141        rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    143142        if (rc != EOK) {
    144                 async_wait_for(req, &rc_orig);
     143                async_wait_for(req, NULL);
    145144                async_serialize_end();
    146145                futex_up(&vfs_phone_futex);
    147146                free(mpa);
    148                 if (rc_orig == EOK)
    149                         return (int) rc;
    150                 else
    151                         return (int) rc_orig;
     147                return (int) rc;
    152148        }
    153149       
    154150        rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
    155151        if (rc != EOK) {
    156                 async_wait_for(req, &rc_orig);
     152                async_wait_for(req, NULL);
    157153                async_serialize_end();
    158154                futex_up(&vfs_phone_futex);
    159155                free(mpa);
    160                 if (rc_orig == EOK)
    161                         return (int) rc;
    162                 else
    163                         return (int) rc_orig;
     156                return (int) rc;
    164157        }
    165158
    166159        rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    167160        if (rc != EOK) {
    168                 async_wait_for(req, &rc_orig);
     161                async_wait_for(req, NULL);
    169162                async_serialize_end();
    170163                futex_up(&vfs_phone_futex);
    171164                free(mpa);
    172                 if (rc_orig == EOK)
    173                         return (int) rc;
    174                 else
    175                         return (int) rc_orig;
     165                return (int) rc;
    176166        }
    177167
    … …  
    179169        rc = async_req_0_0(vfs_phone, IPC_M_PING);
    180170        if (rc != EOK) {
    181                 async_wait_for(req, &rc_orig);
     171                async_wait_for(req, NULL);
    182172                async_serialize_end();
    183173                futex_up(&vfs_phone_futex);
    184174                free(mpa);
    185                 if (rc_orig == EOK)
    186                         return (int) rc;
    187                 else
    188                         return (int) rc_orig;
     175                return (int) rc;
    189176        }
    190177       
    … …  
    215202        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    216203        if (rc != EOK) {
    217                 ipcarg_t rc_orig;
    218        
    219                 async_wait_for(req, &rc_orig);
     204                async_wait_for(req, NULL);
    220205                async_serialize_end();
    221206                futex_up(&vfs_phone_futex);
    222207                free(pa);
    223                 if (rc_orig == EOK)
    224                         return (int) rc;
    225                 else
    226                         return (int) rc_orig;
     208                return (int) rc;
    227209        }
    228210        async_wait_for(req, &rc);
    … …  
    258240       
    259241        if (rc != EOK)
    260                 return (int) rc;
     242            return (int) rc;
    261243       
    262244        return (int) IPC_GET_ARG1(answer);
    … …  
    292274        rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
    293275        if (rc != EOK) {
    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;
     276                async_wait_for(req, NULL);
     277                async_serialize_end();
     278                futex_up(&vfs_phone_futex);
     279                return (ssize_t) rc;
    303280        }
    304281        async_wait_for(req, &rc);
    … …  
    324301        rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
    325302        if (rc != EOK) {
    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;
     303                async_wait_for(req, NULL);
     304                async_serialize_end();
     305                futex_up(&vfs_phone_futex);
     306                return (ssize_t) rc;
    335307        }
    336308        async_wait_for(req, &rc);
    … …  
    404376        rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
    405377        if (rc != EOK) {
    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;
     378                async_wait_for(req, NULL);
     379                async_serialize_end();
     380                futex_up(&vfs_phone_futex);
     381                return (ssize_t) rc;
    415382        }
    416383        async_wait_for(req, &rc);
    … …  
    424391{
    425392        ipcarg_t rc;
    426         ipcarg_t rc_orig;
    427393        aid_t req;
    428394       
    … …  
    439405        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    440406        if (rc != EOK) {
    441                 async_wait_for(req, &rc_orig);
     407                async_wait_for(req, NULL);
    442408                async_serialize_end();
    443409                futex_up(&vfs_phone_futex);
    444410                free(pa);
    445                 if (rc_orig == EOK)
    446                         return (int) rc;
    447                 else
    448                         return (int) rc_orig;
     411                return (int) rc;
    449412        }
    450413        rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
    451414        if (rc != EOK) {
    452                 async_wait_for(req, &rc_orig);
     415                async_wait_for(req, NULL);
    453416                async_serialize_end();
    454417                futex_up(&vfs_phone_futex);
    455418                free(pa);
    456                 if (rc_orig == EOK)
    457                         return (int) rc;
    458                 else
    459                         return (int) rc_orig;
     419                return (int) rc;
    460420        }
    461421        async_wait_for(req, &rc);
    … …  
    516476        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    517477        if (rc != EOK) {
    518                 ipcarg_t rc_orig;
    519        
    520                 async_wait_for(req, &rc_orig);
     478                async_wait_for(req, NULL);
    521479                async_serialize_end();
    522480                futex_up(&vfs_phone_futex);
    523481                free(pa);
    524                 if (rc_orig == EOK)
    525                         return (int) rc;
    526                 else
    527                         return (int) rc_orig;
     482                return (int) rc;
    528483        }
    529484        async_wait_for(req, &rc);
    … …  
    551506        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
    552507        if (rc != EOK) {
    553                 ipcarg_t rc_orig;
    554 
    555                 async_wait_for(req, &rc_orig);
     508                async_wait_for(req, NULL);
    556509                async_serialize_end();
    557510                futex_up(&vfs_phone_futex);
    558511                free(pa);
    559                 if (rc_orig == EOK)
    560                         return (int) rc;
    561                 else
    562                         return (int) rc_orig;
     512                return (int) rc;
    563513        }
    564514        async_wait_for(req, &rc);
    … …  
    582532{
    583533        ipcarg_t rc;
    584         ipcarg_t rc_orig;
    585534        aid_t req;
    586535       
    … …  
    604553        rc = ipc_data_write_start(vfs_phone, olda, olda_size);
    605554        if (rc != EOK) {
    606                 async_wait_for(req, &rc_orig);
     555                async_wait_for(req, NULL);
    607556                async_serialize_end();
    608557                futex_up(&vfs_phone_futex);
    609558                free(olda);
    610559                free(newa);
    611                 if (rc_orig == EOK)
    612                         return (int) rc;
    613                 else
    614                         return (int) rc_orig;
     560                return (int) rc;
    615561        }
    616562        rc = ipc_data_write_start(vfs_phone, newa, newa_size);
    617563        if (rc != EOK) {
    618                 async_wait_for(req, &rc_orig);
     564                async_wait_for(req, NULL);
    619565                async_serialize_end();
    620566                futex_up(&vfs_phone_futex);
    621567                free(olda);
    622568                free(newa);
    623                 if (rc_orig == EOK)
    624                         return (int) rc;
    625                 else
    626                         return (int) rc_orig;
     569                return (int) rc;
    627570        }
    628571        async_wait_for(req, &rc);

  • uspace/srv/fs/fat/fat_fat.c

    rfd210de r75a2dc08  
    451451}
    452452
    453 void
    454 fat_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 
    470453/**
    471454 * @}

  • uspace/srv/fs/fat/fat_fat.h

    rfd210de r75a2dc08  
    8484extern void fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
    8585    off_t);
    86 extern void fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
    8786
    8887#endif

  • uspace/srv/fs/fat/fat_ops.c

    rfd210de r75a2dc08  
    332332        /* idxp->lock held */
    333333        if (flags & L_DIRECTORY) {
    334                 /* Populate the new cluster with unused dentries. */
    335                 fat_zero_cluster(bs, dev_handle, mcl);
     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                }
    336348                nodep->type = FAT_DIRECTORY;
    337349                nodep->firstc = mcl;
    … …  
    450462         * We need to grow the parent in order to create a new unused dentry.
    451463         */
    452         if (parentp->firstc == FAT_CLST_ROOT) {
     464        if (parentp->idx->pfc == FAT_CLST_ROOT) {
    453465                /* Can't grow the root directory. */
    454466                fibril_mutex_unlock(&parentp->idx->lock);
    … …  
    460472                return rc;
    461473        }
    462         fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
    463474        fat_append_clusters(bs, parentp, mcl);
    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);
     475        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
    467476        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));
    468482
    469483hit:

  • uspace/srv/ns/task.h

    rfd210de r75a2dc08  
    3535
    3636#include <ipc/ipc.h>
     37#include <event.h>
    3738
    3839extern int task_init(void);
    3940extern void process_pending_wait(void);
    4041
     42extern void wait_notification(wait_type_t et, task_id_t id);
    4143extern void wait_for_task(task_id_t id, ipc_call_t *call, ipc_callid_t callid);
    4244

  • uspace/srv/vfs/vfs_node.c

    rfd210de r75a2dc08  
    188188        }
    189189
    190         assert(node->size == result->size || node->type != VFS_NODE_FILE);
     190        assert(node->size == result->size);
    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.