Changes in / [e950803:b366a1bc] in mainline


Ignore:
Files:
20 added
2 deleted
21 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/mips32/src/Makefile

    re950803 rb366a1bc  
    3232.PHONY: all clean
    3333
    34 all: ../../../../version ../../../../Makefile.common ../../../../Makefile.config ../../../../config.h
     34all: ../../../../version ../../../../Makefile.config ../../../../config.h ../../../../config.defs
    3535        -[ -f $(DEPEND) ] && mv -f $(DEPEND) $(DEPEND_PREV)
    3636        $(MAKE) -f Makefile.build PRECHECK=$(PRECHECK)
    3737
    3838clean:
    39         rm -f $(USPACEDIR)/dist/srv/*
    40         rm -f $(USPACEDIR)/dist/app/*
    41         rm -f $(USPACEDIR)/dist/cfg/net/*
    42 
    4339        for file in $(RD_SRVS) ; do \
    4440                rm -f $(USPACEDIR)/dist/srv/`basename $$file` ; \
    … …  
    4743                rm -f $(USPACEDIR)/dist/app/`basename $$file` ; \
    4844        done
    49         for file in $(NET_CFG) ; do \
    50                 rm -f $(USPACEDIR)/dist/cfg/net/`basename $$file` ; \
    51         done
    5245        rm -f $(DEPEND) $(DEPEND_PREV) $(JOB) $(OUTPUT) $(RAW) $(COMPS).h $(COMPS).c $(LINK) $(INITRD).img $(INITRD).fs
    5346        find . -name '*.o' -follow -exec rm \{\} \;

  • boot/arch/mips32/src/Makefile.build

    re950803 rb366a1bc  
    3232
    3333include ../../../../version
    34 include ../../../../Makefile.common
    3534include ../../../../Makefile.config
     35include ../../../../config.defs
    3636include Makefile.common
    3737include Makefile.toolchain
    … …  
    7777
    7878$(DEPEND):
    79         rm -f $(USPACEDIR)/dist/srv/*
    80         rm -f $(USPACEDIR)/dist/app/*
    81         rm -f $(USPACEDIR)/dist/cfg/net/*
    82 
    8379        for file in $(RD_SRVS) ; do \
    8480                cp $$file $(USPACEDIR)/dist/srv/ ; \
    … …  
    8682        for file in $(RD_APPS) ; do \
    8783                cp $$file $(USPACEDIR)/dist/app/ ; \
    88         done
    89         for file in $(NET_CFG) ; do \
    90                 cp $$file $(USPACEDIR)/dist/cfg/net/ ; \
    9184        done
    9285ifeq ($(RDFMT),tmpfs)

  • boot/arch/mips32/src/Makefile.toolchain

    re950803 rb366a1bc  
    2727#
    2828
     29## Toolchain configuration
     30#
     31
     32ifndef CROSS_PREFIX
     33        CROSS_PREFIX = /usr/local
     34endif
     35
    2936BFD_ARCH = mips
     37TARGET = mipsel-linux-gnu
     38TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips32/bin
    3039
    3140JOBFILE = ../../../../tools/jobfile.py
    … …  
    3948        BFD_NAME = elf32-tradbigmips
    4049        BFD = ecoff-bigmips
     50        TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips32eb/bin
     51        TARGET = mips-linux-gnu
    4152endif
    4253
    … …  
    4455        BFD_NAME = elf32-tradlittlemips
    4556        BFD = binary
     57endif
     58
     59ifeq ($(COMPILER),gcc_native)
     60        CC = gcc
     61        AS = as
     62        LD = ld
     63        OBJCOPY = objcopy
     64        OBJDUMP = objdump
     65endif
     66
     67ifeq ($(COMPILER),gcc_cross)
     68        CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc
     69        AS = $(TOOLCHAIN_DIR)/$(TARGET)-as
     70        LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld
     71        OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy
     72        OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
    4673endif
    4774

  • kernel/arch/ia32/_link.ld.in

    re950803 rb366a1bc  
    4949        }
    5050       
    51 #ifdef CONFIG_LINE_DEBUG
    52         .comment 0 : { *(.comment); }
    53         .debug_abbrev 0 : { *(.debug_abbrev); }
    54         .debug_aranges 0 : { *(.debug_aranges); }
    55         .debug_info 0 : { *(.debug_info); }
    56         .debug_line 0 : { *(.debug_line); }
    57         .debug_loc 0 : { *(.debug_loc); }
    58         .debug_pubnames 0 : { *(.debug_pubnames); }
    59         .debug_pubtypes 0 : { *(.debug_pubtypes); }
    60         .debug_ranges 0 : { *(.debug_ranges); }
    61         .debug_str 0 : { *(.debug_str); }
    62 #endif
    63        
    6451        /DISCARD/ : {
    65                 *(*);
     52                *(.note.GNU-stack);
     53                *(.comment);
    6654        }
    6755       

  • kernel/arch/mips32/src/mm/tlb.c

    re950803 rb366a1bc  
    557557        entry_hi_t hi, hi_save;
    558558        tlb_index_t index;
    559        
    560         if (asid == ASID_INVALID)
    561                 return;
     559
     560        ASSERT(asid != ASID_INVALID);
    562561
    563562        hi_save.value = cp0_entry_hi_read();

  • kernel/generic/include/mm/as.h

    re950803 rb366a1bc  
    115115       
    116116        /**
    117          * Number of processors on which this
    118          * address space is active. Protected by
    119          * asidlock.
     117         * Number of processors on wich is this address space active.
     118         * Protected by asidlock.
    120119         */
    121120        size_t cpu_refcount;
    122121       
    123         /** Address space identifier.
    124          *
    125          * Constant on architectures that do not
    126          * support ASIDs. Protected by asidlock.
    127          *
     122        /**
     123         * Address space identifier.
     124         * Constant on architectures that do not support ASIDs.
     125         * Protected by asidlock.
    128126         */
    129127        asid_t asid;
    130128       
    131         /** Number of references (i.e. tasks that reference this as). */
     129        /** Number of references (i.e tasks that reference this as). */
    132130        atomic_t refcount;
    133131       
    … …  
    201199typedef struct {
    202200        mutex_t lock;
    203        
    204201        /** Containing address space. */
    205202        as_t *as;
    206203       
    207         /** Memory flags. */
     204        /**
     205         * Flags related to the memory represented by the address space area.
     206         */
    208207        unsigned int flags;
    209208       
    210         /** Address space area attributes. */
     209        /** Attributes related to the address space area itself. */
    211210        unsigned int attributes;
    212        
    213         /** Number of pages in the area. */
     211        /** Size of this area in multiples of PAGE_SIZE. */
    214212        size_t pages;
    215        
    216         /** Number of resident pages in the area. */
    217         size_t resident;
    218        
    219213        /** Base address of this area. */
    220214        uintptr_t base;
    221        
    222215        /** Map of used space. */
    223216        btree_t used_space;
    224217       
    225218        /**
    226          * If the address space area is shared. this is
    227          * a reference to the share info structure.
     219         * If the address space area has been shared, this pointer will
     220         * reference the share info structure.
    228221         */
    229222        share_info_t *sh_info;
    … …  
    268261extern bool as_area_check_access(as_area_t *, pf_access_t);
    269262extern size_t as_area_get_size(uintptr_t);
    270 extern bool used_space_insert(as_area_t *, uintptr_t, size_t);
    271 extern bool used_space_remove(as_area_t *, uintptr_t, size_t);
     263extern int used_space_insert(as_area_t *, uintptr_t, size_t);
     264extern int used_space_remove(as_area_t *, uintptr_t, size_t);
     265
    272266
    273267/* Interface to be implemented by architectures. */

  • kernel/generic/src/console/cmd.c

    re950803 rb366a1bc  
    553553        for (i = 0; basic_commands[i]; i++) {
    554554                cmd_initialize(basic_commands[i]);
    555         }
    556 
    557         for (i = 0; basic_commands[i]; i++) {
    558                 if (!cmd_register(basic_commands[i])) {
    559                         printf("Cannot register command %s\n",
    560                             basic_commands[i]->name);
    561                 }
     555                if (!cmd_register(basic_commands[i]))
     556                        printf("Cannot register command %s\n", basic_commands[i]->name);
    562557        }
    563558}

  • kernel/generic/src/lib/elf.c

    re950803 rb366a1bc  
    157157        case PT_NULL:
    158158        case PT_PHDR:
    159         case PT_NOTE:
    160159                break;
    161160        case PT_LOAD:
    … …  
    174173                break;
    175174        case PT_SHLIB:
     175        case PT_NOTE:
    176176        case PT_LOPROC:
    177177        case PT_HIPROC:

  • kernel/generic/src/mm/as.c

    re950803 rb366a1bc  
    8686 * Each architecture decides what functions will be used to carry out
    8787 * address space operations such as creating or locking page tables.
     88 *
    8889 */
    8990as_operations_t *as_operations = NULL;
    9091
    91 /** Slab for as_t objects.
     92/**
     93 * Slab for as_t objects.
    9294 *
    9395 */
    9496static slab_cache_t *as_slab;
    9597
    96 /** ASID subsystem lock.
    97  *
    98  * This lock protects:
     98/**
     99 * This lock serializes access to the ASID subsystem.
     100 * It protects:
    99101 * - inactive_as_with_asid_head list
    100102 * - as->asid for each as of the as_t type
    … …  
    105107
    106108/**
    107  * Inactive address spaces (on all processors)
    108  * that have valid ASID.
     109 * This list contains address spaces that are not active on any
     110 * processor and that have valid ASID.
     111 *
    109112 */
    110113LIST_INITIALIZE(inactive_as_with_asid_head);
    … …  
    120123        mutex_initialize(&as->lock, MUTEX_PASSIVE);
    121124       
    122         return as_constructor_arch(as, flags);
     125        int rc = as_constructor_arch(as, flags);
     126       
     127        return rc;
    123128}
    124129
    125130NO_TRACE static size_t as_destructor(void *obj)
    126131{
    127         return as_destructor_arch((as_t *) obj);
     132        as_t *as = (as_t *) obj;
     133        return as_destructor_arch(as);
    128134}
    129135
    … …  
    140146                panic("Cannot create kernel address space.");
    141147       
    142         /*
    143          * Make sure the kernel address space
     148        /* Make sure the kernel address space
    144149         * reference count never drops to zero.
    145150         */
    … …  
    190195{
    191196        DEADLOCK_PROBE_INIT(p_asidlock);
    192        
     197
    193198        ASSERT(as != AS);
    194199        ASSERT(atomic_get(&as->refcount) == 0);
    … …  
    198203         * lock its mutex.
    199204         */
    200        
     205
    201206        /*
    202207         * We need to avoid deadlock between TLB shootdown and asidlock.
    … …  
    205210         * disabled to prevent nested context switches. We also depend on the
    206211         * fact that so far no spinlocks are held.
     212         *
    207213         */
    208214        preemption_disable();
    … …  
    229235        spinlock_unlock(&asidlock);
    230236        interrupts_restore(ipl);
    231        
     237
    232238       
    233239        /*
    … …  
    235241         * The B+tree must be walked carefully because it is
    236242         * also being destroyed.
     243         *
    237244         */
    238245        bool cond = true;
    … …  
    261268/** Hold a reference to an address space.
    262269 *
    263  * Holding a reference to an address space prevents destruction
    264  * of that address space.
     270 * Holding a reference to an address space prevents destruction of that address
     271 * space.
    265272 *
    266273 * @param as Address space to be held.
    … …  
    274281/** Release a reference to an address space.
    275282 *
    276  * The last one to release a reference to an address space
    277  * destroys the address space.
     283 * The last one to release a reference to an address space destroys the address
     284 * space.
    278285 *
    279286 * @param asAddress space to be released.
    … …  
    303310        /*
    304311         * We don't want any area to have conflicts with NULL page.
     312         *
    305313         */
    306314        if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE))
    … …  
    313321         * record in the left neighbour, the leftmost record in the right
    314322         * neighbour and all records in the leaf node itself.
     323         *
    315324         */
    316325        btree_node_t *leaf;
    … …  
    373382         * So far, the area does not conflict with other areas.
    374383         * Check if it doesn't conflict with kernel address space.
     384         *
    375385         */
    376386        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    … …  
    427437        area->attributes = attrs;
    428438        area->pages = SIZE2FRAMES(size);
    429         area->resident = 0;
    430439        area->base = base;
    431440        area->sh_info = NULL;
    … …  
    470479         * to find out whether this is a miss or va belongs to an address
    471480         * space area found there.
     481         *
    472482         */
    473483       
    … …  
    489499         * Second, locate the left neighbour and test its last record.
    490500         * Because of its position in the B+tree, it must have base < va.
     501         *
    491502         */
    492503        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
    … …  
    523534        /*
    524535         * Locate the area.
     536         *
    525537         */
    526538        as_area_t *area = find_area_and_lock(as, address);
    … …  
    534546                 * Remapping of address space areas associated
    535547                 * with memory mapped devices is not supported.
     548                 *
    536549                 */
    537550                mutex_unlock(&area->lock);
    … …  
    544557                 * Remapping of shared address space areas
    545558                 * is not supported.
     559                 *
    546560                 */
    547561                mutex_unlock(&area->lock);
    … …  
    554568                /*
    555569                 * Zero size address space areas are not allowed.
     570                 *
    556571                 */
    557572                mutex_unlock(&area->lock);
    … …  
    566581                 * Shrinking the area.
    567582                 * No need to check for overlaps.
     583                 *
    568584                 */
    569585               
    … …  
    572588                /*
    573589                 * Start TLB shootdown sequence.
     590                 *
    574591                 */
    575592                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
    … …  
    582599                 * is also the right way to remove part of the used_space
    583600                 * B+tree leaf list.
     601                 *
    584602                 */
    585603                bool cond = true;
    … …  
    605623                                                 * completely in the resized
    606624                                                 * address space area.
     625                                                 *
    607626                                                 */
    608627                                                break;
    … …  
    613632                                         * to b and c overlaps with the resized
    614633                                         * address space area.
     634                                         *
    615635                                         */
    616636                                       
    … …  
    653673                /*
    654674                 * Finish TLB shootdown sequence.
     675                 *
    655676                 */
    656677               
    … …  
    660681                /*
    661682                 * Invalidate software translation caches (e.g. TSB on sparc64).
     683                 *
    662684                 */
    663685                as_invalidate_translation_cache(as, area->base +
    … …  
    670692                 * Growing the area.
    671693                 * Check for overlaps with other address space areas.
     694                 *
    672695                 */
    673696                if (!check_area_conflicts(as, address, pages * PAGE_SIZE,
    … …  
    790813        /*
    791814         * Finish TLB shootdown sequence.
     815         *
    792816         */
    793817       
    … …  
    797821         * Invalidate potential software translation caches (e.g. TSB on
    798822         * sparc64).
     823         *
    799824         */
    800825        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    814839        /*
    815840         * Remove the empty area from address space.
     841         *
    816842         */
    817843        btree_remove(&as->as_area_btree, base, NULL);
    … …  
    855881                /*
    856882                 * Could not find the source address space area.
     883                 *
    857884                 */
    858885                mutex_unlock(&src_as->lock);
    … …  
    864891                 * There is no backend or the backend does not
    865892                 * know how to share the area.
     893                 *
    866894                 */
    867895                mutex_unlock(&src_area->lock);
    … …  
    890918         * First, prepare the area for sharing.
    891919         * Then it will be safe to unlock it.
     920         *
    892921         */
    893922        share_info_t *sh_info = src_area->sh_info;
    … …  
    901930                /*
    902931                 * Call the backend to setup sharing.
     932                 *
    903933                 */
    904934                src_area->backend->share(src_area);
    … …  
    919949         * The flags of the source area are masked against dst_flags_mask
    920950         * to support sharing in less privileged mode.
     951         *
    921952         */
    922953        as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, src_size,
    … …  
    935966         * fully initialized. Clear the AS_AREA_ATTR_PARTIAL
    936967         * attribute and set the sh_info.
     968         *
    937969         */
    938970        mutex_lock(&dst_as->lock);
    … …  
    957989NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
    958990{
    959         ASSERT(mutex_locked(&area->lock));
    960        
    961991        int flagmap[] = {
    962992                [PF_ACCESS_READ] = AS_AREA_READ,
    … …  
    964994                [PF_ACCESS_EXEC] = AS_AREA_EXEC
    965995        };
     996
     997        ASSERT(mutex_locked(&area->lock));
    966998       
    967999        if (!(area->flags & flagmap[access]))
    … …  
    10341066        /*
    10351067         * Compute total number of used pages in the used_space B+tree
     1068         *
    10361069         */
    10371070        size_t used_pages = 0;
    … …  
    10551088        /*
    10561089         * Start TLB shootdown sequence.
     1090         *
    10571091         */
    10581092        ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base,
    … …  
    10621096         * Remove used pages from page tables and remember their frame
    10631097         * numbers.
     1098         *
    10641099         */
    10651100        size_t frame_idx = 0;
    … …  
    10921127        /*
    10931128         * Finish TLB shootdown sequence.
     1129         *
    10941130         */
    10951131       
    … …  
    10991135         * Invalidate potential software translation caches (e.g. TSB on
    11001136         * sparc64).
     1137         *
    11011138         */
    11021139        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    11801217                 * No area contained mapping for 'page'.
    11811218                 * Signal page fault to low-level handler.
     1219                 *
    11821220                 */
    11831221                mutex_unlock(&AS->lock);
    … …  
    11991237                 * The address space area is not backed by any backend
    12001238                 * or the backend cannot handle page faults.
     1239                 *
    12011240                 */
    12021241                mutex_unlock(&area->lock);
    … …  
    12101249         * To avoid race condition between two page faults on the same address,
    12111250         * we need to make sure the mapping has not been already inserted.
     1251         *
    12121252         */
    12131253        pte_t *pte;
    … …  
    12271267        /*
    12281268         * Resort to the backend page fault handler.
     1269         *
    12291270         */
    12301271        if (area->backend->page_fault(area, page, access) != AS_PF_OK) {
    … …  
    12811322                 * preemption is disabled. We should not be
    12821323                 * holding any other lock.
     1324                 *
    12831325                 */
    12841326                (void) interrupts_enable();
    … …  
    13001342                         * list of inactive address spaces with assigned
    13011343                         * ASID.
     1344                         *
    13021345                         */
    13031346                        ASSERT(old_as->asid != ASID_INVALID);
    … …  
    13101353                 * Perform architecture-specific tasks when the address space
    13111354                 * is being removed from the CPU.
     1355                 *
    13121356                 */
    13131357                as_deinstall_arch(old_as);
    … …  
    13161360        /*
    13171361         * Second, prepare the new address space.
     1362         *
    13181363         */
    13191364        if ((new_as->cpu_refcount++ == 0) && (new_as != AS_KERNEL)) {
    … …  
    13311376         * Perform architecture-specific steps.
    13321377         * (e.g. write ASID to hardware register etc.)
     1378         *
    13331379         */
    13341380        as_install_arch(new_as);
    … …  
    13491395{
    13501396        ASSERT(mutex_locked(&area->lock));
    1351        
     1397
    13521398        return area_flags_to_page_flags(area->flags);
    13531399}
    … …  
    14701516 * @param count Number of page to be marked.
    14711517 *
    1472  * @return False on failure or true on success.
    1473  *
    1474  */
    1475 bool used_space_insert(as_area_t *area, uintptr_t page, size_t count)
     1518 * @return Zero on failure and non-zero on success.
     1519 *
     1520 */
     1521int used_space_insert(as_area_t *area, uintptr_t page, size_t count)
    14761522{
    14771523        ASSERT(mutex_locked(&area->lock));
    … …  
    14841530                /*
    14851531                 * We hit the beginning of some used space.
    1486                  */
    1487                 return false;
     1532                 *
     1533                 */
     1534                return 0;
    14881535        }
    14891536       
    14901537        if (!leaf->keys) {
    14911538                btree_insert(&area->used_space, page, (void *) count, leaf);
    1492                 goto success;
     1539                return 1;
    14931540        }
    14941541       
    … …  
    15041551                 * somewhere between the rightmost interval of
    15051552                 * the left neigbour and the first interval of the leaf.
     1553                 *
    15061554                 */
    15071555               
    … …  
    15111559                    left_cnt * PAGE_SIZE)) {
    15121560                        /* The interval intersects with the left interval. */
    1513                         return false;
     1561                        return 0;
    15141562                } else if (overlaps(page, count * PAGE_SIZE, right_pg,
    15151563                    right_cnt * PAGE_SIZE)) {
    15161564                        /* The interval intersects with the right interval. */
    1517                         return false;
     1565                        return 0;
    15181566                } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
    15191567                    (page + count * PAGE_SIZE == right_pg)) {
    … …  
    15211569                         * The interval can be added by merging the two already
    15221570                         * present intervals.
     1571                         *
    15231572                         */
    15241573                        node->value[node->keys - 1] += count + right_cnt;
    15251574                        btree_remove(&area->used_space, right_pg, leaf);
    1526                         goto success;
     1575                        return 1;
    15271576                } else if (page == left_pg + left_cnt * PAGE_SIZE) {
    15281577                        /*
    15291578                         * The interval can be added by simply growing the left
    15301579                         * interval.
     1580                         *
    15311581                         */
    15321582                        node->value[node->keys - 1] += count;
    1533                         goto success;
     1583                        return 1;
    15341584                } else if (page + count * PAGE_SIZE == right_pg) {
    15351585                        /*
    … …  
    15371587                         * the right interval down and increasing its size
    15381588                         * accordingly.
     1589                         *
    15391590                         */
    15401591                        leaf->value[0] += count;
    15411592                        leaf->key[0] = page;
    1542                         goto success;
     1593                        return 1;
    15431594                } else {
    15441595                        /*
    15451596                         * The interval is between both neigbouring intervals,
    15461597                         * but cannot be merged with any of them.
     1598                         *
    15471599                         */
    15481600                        btree_insert(&area->used_space, page, (void *) count,
    15491601                            leaf);
    1550                         goto success;
     1602                        return 1;
    15511603                }
    15521604        } else if (page < leaf->key[0]) {
    … …  
    15571609                 * Investigate the border case in which the left neighbour does
    15581610                 * not exist but the interval fits from the left.
     1611                 *
    15591612                 */
    15601613               
    … …  
    15621615                    right_cnt * PAGE_SIZE)) {
    15631616                        /* The interval intersects with the right interval. */
    1564                         return false;
     1617                        return 0;
    15651618                } else if (page + count * PAGE_SIZE == right_pg) {
    15661619                        /*
    … …  
    15681621                         * right interval down and increasing its size
    15691622                         * accordingly.
     1623                         *
    15701624                         */
    15711625                        leaf->key[0] = page;
    15721626                        leaf->value[0] += count;
    1573                         goto success;
     1627                        return 1;
    15741628                } else {
    15751629                        /*
    15761630                         * The interval doesn't adjoin with the right interval.
    15771631                         * It must be added individually.
     1632                         *
    15781633                         */
    15791634                        btree_insert(&area->used_space, page, (void *) count,
    15801635                            leaf);
    1581                         goto success;
     1636                        return 1;
    15821637                }
    15831638        }
    … …  
    15941649                 * somewhere between the leftmost interval of
    15951650                 * the right neigbour and the last interval of the leaf.
     1651                 *
    15961652                 */
    15971653               
    … …  
    16011657                    left_cnt * PAGE_SIZE)) {
    16021658                        /* The interval intersects with the left interval. */
    1603                         return false;
     1659                        return 0;
    16041660                } else if (overlaps(page, count * PAGE_SIZE, right_pg,
    16051661                    right_cnt * PAGE_SIZE)) {
    16061662                        /* The interval intersects with the right interval. */
    1607                         return false;
     1663                        return 0;
    16081664                } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
    16091665                    (page + count * PAGE_SIZE == right_pg)) {
    … …  
    16111667                         * The interval can be added by merging the two already
    16121668                         * present intervals.
     1669                         *
    16131670                         */
    16141671                        leaf->value[leaf->keys - 1] += count + right_cnt;
    16151672                        btree_remove(&area->used_space, right_pg, node);
    1616                         goto success;
     1673                        return 1;
    16171674                } else if (page == left_pg + left_cnt * PAGE_SIZE) {
    16181675                        /*
    16191676                         * The interval can be added by simply growing the left
    16201677                         * interval.
     1678                         *
    16211679                         */
    1622                         leaf->value[leaf->keys - 1] += count;
    1623                         goto success;
     1680                        leaf->value[leaf->keys - 1] +=  count;
     1681                        return 1;
    16241682                } else if (page + count * PAGE_SIZE == right_pg) {
    16251683                        /*
    … …  
    16271685                         * the right interval down and increasing its size
    16281686                         * accordingly.
     1687                         *
    16291688                         */
    16301689                        node->value[0] += count;
    16311690                        node->key[0] = page;
    1632                         goto success;
     1691                        return 1;
    16331692                } else {
    16341693                        /*
    16351694                         * The interval is between both neigbouring intervals,
    16361695                         * but cannot be merged with any of them.
     1696                         *
    16371697                         */
    16381698                        btree_insert(&area->used_space, page, (void *) count,
    16391699                            leaf);
    1640                         goto success;
     1700                        return 1;
    16411701                }
    16421702        } else if (page >= leaf->key[leaf->keys - 1]) {
    … …  
    16471707                 * Investigate the border case in which the right neighbour
    16481708                 * does not exist but the interval fits from the right.
     1709                 *
    16491710                 */
    16501711               
    … …  
    16521713                    left_cnt * PAGE_SIZE)) {
    16531714                        /* The interval intersects with the left interval. */
    1654                         return false;
     1715                        return 0;
    16551716                } else if (left_pg + left_cnt * PAGE_SIZE == page) {
    16561717                        /*
    16571718                         * The interval can be added by growing the left
    16581719                         * interval.
     1720                         *
    16591721                         */
    16601722                        leaf->value[leaf->keys - 1] += count;
    1661                         goto success;
     1723                        return 1;
    16621724                } else {
    16631725                        /*
    16641726                         * The interval doesn't adjoin with the left interval.
    16651727                         * It must be added individually.
     1728                         *
    16661729                         */
    16671730                        btree_insert(&area->used_space, page, (void *) count,
    16681731                            leaf);
    1669                         goto success;
     1732                        return 1;
    16701733                }
    16711734        }
    … …  
    16751738         * only between two other intervals of the leaf. The two border cases
    16761739         * were already resolved.
     1740         *
    16771741         */
    16781742        btree_key_t i;
    … …  
    16861750                        /*
    16871751                         * The interval fits between left_pg and right_pg.
     1752                         *
    16881753                         */
    16891754                       
    … …  
    16931758                                 * The interval intersects with the left
    16941759                                 * interval.
     1760                                 *
    16951761                                 */
    1696                                 return false;
     1762                                return 0;
    16971763                        } else if (overlaps(page, count * PAGE_SIZE, right_pg,
    16981764                            right_cnt * PAGE_SIZE)) {
    … …  
    17001766                                 * The interval intersects with the right
    17011767                                 * interval.
     1768                                 *
    17021769                                 */
    1703                                 return false;
     1770                                return 0;
    17041771                        } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
    17051772                            (page + count * PAGE_SIZE == right_pg)) {
    … …  
    17071774                                 * The interval can be added by merging the two
    17081775                                 * already present intervals.
     1776                                 *
    17091777                                 */
    17101778                                leaf->value[i - 1] += count + right_cnt;
    17111779                                btree_remove(&area->used_space, right_pg, leaf);
    1712                                 goto success;
     1780                                return 1;
    17131781                        } else if (page == left_pg + left_cnt * PAGE_SIZE) {
    17141782                                /*
    17151783                                 * The interval can be added by simply growing
    17161784                                 * the left interval.
     1785                                 *
    17171786                                 */
    17181787                                leaf->value[i - 1] += count;
    1719                                 goto success;
     1788                                return 1;
    17201789                        } else if (page + count * PAGE_SIZE == right_pg) {
    17211790                                /*
    … …  
    17231792                                 * base of the right interval down and
    17241793                                 * increasing its size accordingly.
     1794                                 *
    17251795                                 */
    17261796                                leaf->value[i] += count;
    17271797                                leaf->key[i] = page;
    1728                                 goto success;
     1798                                return 1;
    17291799                        } else {
    17301800                                /*
    … …  
    17321802                                 * intervals, but cannot be merged with any of
    17331803                                 * them.
     1804                                 *
    17341805                                 */
    17351806                                btree_insert(&area->used_space, page,
    17361807                                    (void *) count, leaf);
    1737                                 goto success;
     1808                                return 1;
    17381809                        }
    17391810                }
    … …  
    17421813        panic("Inconsistency detected while adding %zu pages of used "
    17431814            "space at %p.", count, (void *) page);
    1744        
    1745 success:
    1746         area->resident += count;
    1747         return true;
    17481815}
    17491816
    … …  
    17561823 * @param count Number of page to be marked.
    17571824 *
    1758  * @return False on failure or true on success.
    1759  *
    1760  */
    1761 bool used_space_remove(as_area_t *area, uintptr_t page, size_t count)
     1825 * @return Zero on failure and non-zero on success.
     1826 *
     1827 */
     1828int used_space_remove(as_area_t *area, uintptr_t page, size_t count)
    17621829{
    17631830        ASSERT(mutex_locked(&area->lock));
    … …  
    17701837                /*
    17711838                 * We are lucky, page is the beginning of some interval.
     1839                 *
    17721840                 */
    17731841                if (count > pages) {
    1774                         return false;
     1842                        return 0;
    17751843                } else if (count == pages) {
    17761844                        btree_remove(&area->used_space, page, leaf);
    1777                         goto success;
     1845                        return 1;
    17781846                } else {
    17791847                        /*
    17801848                         * Find the respective interval.
    17811849                         * Decrease its size and relocate its start address.
     1850                         *
    17821851                         */
    17831852                        btree_key_t i;
    … …  
    17861855                                        leaf->key[i] += count * PAGE_SIZE;
    17871856                                        leaf->value[i] -= count;
    1788                                         goto success;
     1857                                        return 1;
    17891858                                }
    17901859                        }
    1791                        
    17921860                        goto error;
    17931861                }
    … …  
    18081876                                 * removed by updating the size of the bigger
    18091877                                 * interval.
     1878                                 *
    18101879                                 */
    18111880                                node->value[node->keys - 1] -= count;
    1812                                 goto success;
     1881                                return 1;
    18131882                        } else if (page + count * PAGE_SIZE <
    18141883                            left_pg + left_cnt*PAGE_SIZE) {
    … …  
    18191888                                 * the original interval and also inserting a
    18201889                                 * new interval.
     1890                                 *
    18211891                                 */
    18221892                                size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
    … …  
    18251895                                btree_insert(&area->used_space, page +
    18261896                                    count * PAGE_SIZE, (void *) new_cnt, leaf);
    1827                                 goto success;
     1897                                return 1;
    18281898                        }
    18291899                }
    1830                
    1831                 return false;
     1900                return 0;
    18321901        } else if (page < leaf->key[0])
    1833                 return false;
     1902                return 0;
    18341903       
    18351904        if (page > leaf->key[leaf->keys - 1]) {
    … …  
    18451914                                 * interval of the leaf and can be removed by
    18461915                                 * updating the size of the bigger interval.
     1916                                 *
    18471917                                 */
    18481918                                leaf->value[leaf->keys - 1] -= count;
    1849                                 goto success;
     1919                                return 1;
    18501920                        } else if (page + count * PAGE_SIZE < left_pg +
    18511921                            left_cnt * PAGE_SIZE) {
    … …  
    18561926                                 * original interval and also inserting a new
    18571927                                 * interval.
     1928                                 *
    18581929                                 */
    18591930                                size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
    … …  
    18621933                                btree_insert(&area->used_space, page +
    18631934                                    count * PAGE_SIZE, (void *) new_cnt, leaf);
    1864                                 goto success;
     1935                                return 1;
    18651936                        }
    18661937                }
    1867                
    1868                 return false;
     1938                return 0;
    18691939        }
    18701940       
    18711941        /*
    18721942         * The border cases have been already resolved.
    1873          * Now the interval can be only between intervals of the leaf.
     1943         * Now the interval can be only between intervals of the leaf. 
    18741944         */
    18751945        btree_key_t i;
    … …  
    18921962                                         * be removed by updating the size of
    18931963                                         * the bigger interval.
     1964                                         *
    18941965                                         */
    18951966                                        leaf->value[i - 1] -= count;
    1896                                         goto success;
     1967                                        return 1;
    18971968                                } else if (page + count * PAGE_SIZE <
    18981969                                    left_pg + left_cnt * PAGE_SIZE) {
    … …  
    19121983                                            count * PAGE_SIZE, (void *) new_cnt,
    19131984                                            leaf);
    1914                                         goto success;
     1985                                        return 1;
    19151986                                }
    19161987                        }
    1917                        
    1918                         return false;
     1988                        return 0;
    19191989                }
    19201990        }
    … …  
    19231993        panic("Inconsistency detected while removing %zu pages of used "
    19241994            "space from %p.", count, (void *) page);
    1925        
    1926 success:
    1927         area->resident -= count;
    1928         return true;
    19291995}
    19301996

  • kernel/generic/src/sysinfo/stats.c

    re950803 rb366a1bc  
    160160static size_t get_task_virtmem(as_t *as)
    161161{
     162        size_t result = 0;
     163
    162164        /*
    163          * We are holding spinlocks here and therefore are not allowed to
    164          * block. Only attempt to lock the address space and address space
    165          * area mutexes conditionally. If it is not possible to lock either
    166          * object, return inexact statistics by skipping the respective object.
     165         * We are holding some spinlocks here and therefore are not allowed to
     166         * block. Only attempt to lock the address space and address space area
     167         * mutexes conditionally. If it is not possible to lock either object,
     168         * allow the statistics to be inexact by skipping the respective object.
     169         *
     170         * Note that it may be infinitely better to let the address space
     171         * management code compute these statistics as it proceeds instead of
     172         * having them calculated over and over again here.
    167173         */
    168        
     174
    169175        if (SYNCH_FAILED(mutex_trylock(&as->lock)))
    170                 return 0;
    171        
    172         size_t pages = 0;
     176                return result * PAGE_SIZE;
    173177       
    174178        /* Walk the B+ tree and count pages */
     179        link_t *cur;
     180        for (cur = as->as_area_btree.leaf_head.next;
     181            cur != &as->as_area_btree.leaf_head; cur = cur->next) {
     182                btree_node_t *node =
     183                    list_get_instance(cur, btree_node_t, leaf_link);
     184               
     185                unsigned int i;
     186                for (i = 0; i < node->keys; i++) {
     187                        as_area_t *area = node->value[i];
     188                       
     189                        if (SYNCH_FAILED(mutex_trylock(&area->lock)))
     190                                continue;
     191                        result += area->pages;
     192                        mutex_unlock(&area->lock);
     193                }
     194        }
     195       
     196        mutex_unlock(&as->lock);
     197       
     198        return result * PAGE_SIZE;
     199}
     200
     201/** Get the resident (used) size of a virtual address space
     202 *
     203 * @param as Address space.
     204 *
     205 * @return Size of the resident (used) virtual address space (bytes).
     206 *
     207 */
     208static size_t get_task_resmem(as_t *as)
     209{
     210        size_t result = 0;
     211       
     212        /*
     213         * We are holding some spinlocks here and therefore are not allowed to
     214         * block. Only attempt to lock the address space and address space area
     215         * mutexes conditionally. If it is not possible to lock either object,
     216         * allow the statistics to be inexact by skipping the respective object.
     217         *
     218         * Note that it may be infinitely better to let the address space
     219         * management code compute these statistics as it proceeds instead of
     220         * having them calculated over and over again here.
     221         */
     222       
     223        if (SYNCH_FAILED(mutex_trylock(&as->lock)))
     224                return result * PAGE_SIZE;
     225       
     226        /* Walk the B+ tree of AS areas */
    175227        link_t *cur;
    176228        for (cur = as->as_area_btree.leaf_head.next;
    … …  
    186238                                continue;
    187239                       
    188                         pages += area->pages;
     240                        /* Walk the B+ tree of resident pages */
     241                        link_t *rcur;
     242                        for (rcur = area->used_space.leaf_head.next;
     243                            rcur != &area->used_space.leaf_head; rcur = rcur->next) {
     244                                btree_node_t *rnode =
     245                                    list_get_instance(rcur, btree_node_t, leaf_link);
     246                               
     247                                unsigned int j;
     248                                for (j = 0; j < rnode->keys; j++)
     249                                        result += (size_t) rnode->value[i];
     250                        }
     251                       
    189252                        mutex_unlock(&area->lock);
    190253                }
    … …  
    193256        mutex_unlock(&as->lock);
    194257       
    195         return (pages << PAGE_WIDTH);
    196 }
    197 
    198 /** Get the resident (used) size of a virtual address space
    199  *
    200  * @param as Address space.
    201  *
    202  * @return Size of the resident (used) virtual address space (bytes).
    203  *
    204  */
    205 static size_t get_task_resmem(as_t *as)
    206 {
    207         /*
    208          * We are holding spinlocks here and therefore are not allowed to
    209          * block. Only attempt to lock the address space and address space
    210          * area mutexes conditionally. If it is not possible to lock either
    211          * object, return inexact statistics by skipping the respective object.
    212          */
    213        
    214         if (SYNCH_FAILED(mutex_trylock(&as->lock)))
    215                 return 0;
    216        
    217         size_t pages = 0;
    218        
    219         /* Walk the B+ tree and count pages */
    220         link_t *cur;
    221         for (cur = as->as_area_btree.leaf_head.next;
    222             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
    223                 btree_node_t *node =
    224                     list_get_instance(cur, btree_node_t, leaf_link);
    225                
    226                 unsigned int i;
    227                 for (i = 0; i < node->keys; i++) {
    228                         as_area_t *area = node->value[i];
    229                        
    230                         if (SYNCH_FAILED(mutex_trylock(&area->lock)))
    231                                 continue;
    232                        
    233                         pages += area->resident;
    234                         mutex_unlock(&area->lock);
    235                 }
    236         }
    237        
    238         mutex_unlock(&as->lock);
    239        
    240         return (pages << PAGE_WIDTH);
     258        return result * PAGE_SIZE;
    241259}
    242260

  • uspace/Makefile.common

    re950803 rb366a1bc  
    135135endif
    136136
    137 ifeq ($(CONFIG_LINE_DEBUG),y)
    138         GCC_CFLAGS += -g
    139         ICC_CFLAGS += -g
    140         SUNCC_CFLAGS += -g
    141         CLANG_CFLAGS += -g
    142 endif
    143 
    144137## Setup platform configuration
    145138#

  • uspace/drv/test2/test2.c

    re950803 rb366a1bc  
    103103        if (dev->parent == NULL) {
    104104                fid_t postpone = fibril_create(postponed_birth, dev);
    105                 if (postpone == 0) {
    106                         printf(NAME ": fibril_create() error\n");
    107                         return ENOMEM;
    108                 }
    109105                fibril_add_ready(postpone);
    110106        } else {

  • uspace/lib/c/arch/amd64/_link.ld.in

    re950803 rb366a1bc  
    55        text PT_LOAD FLAGS(5);
    66        data PT_LOAD FLAGS(6);
    7         debug PT_NOTE;
    87}
    98
    … …  
    1413                *(.init);
    1514        } :text
    16        
    1715        .text : {
    1816                *(.text);
    1917                *(.rodata*);
    2018        } :text
    21        
     19
    2220        . = . + 0x1000;
    23        
     21
    2422        .data : {
    2523                *(.data);
    2624        } :data
    27        
    2825        .tdata : {
    2926                _tdata_start = .;
    … …  
    3431                _tbss_end = .;
    3532        } :data
    36        
    3733        _tls_alignment = ALIGNOF(.tdata);
    38        
    3934        .bss : {
    4035                *(COMMON);
    4136                *(.bss);
    4237        } :data
    43        
     38
    4439        . = ALIGN(0x1000);
    4540        _heap = .;
    46        
    47 #ifdef CONFIG_LINE_DEBUG
    48         .comment 0 : { *(.comment); } :debug
    49         .debug_abbrev 0 : { *(.debug_abbrev); } :debug
    50         .debug_aranges 0 : { *(.debug_aranges); } :debug
    51         .debug_info 0 : { *(.debug_info); } :debug
    52         .debug_line 0 : { *(.debug_line); } :debug
    53         .debug_loc 0 : { *(.debug_loc); } :debug
    54         .debug_pubnames 0 : { *(.debug_pubnames); } :debug
    55         .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
    56         .debug_ranges 0 : { *(.debug_ranges); } :debug
    57         .debug_str 0 : { *(.debug_str); } :debug
    58 #endif
    5941       
    6042        /DISCARD/ : {

  • uspace/lib/c/arch/ia32/_link.ld.in

    re950803 rb366a1bc  
    55        text PT_LOAD FLAGS(5);
    66        data PT_LOAD FLAGS(6);
    7         debug PT_NOTE;
    87}
    98
    … …  
    4443       
    4544        . = ALIGN(0x1000);
     45       
    4646        _heap = .;
    47        
    48 #ifdef CONFIG_LINE_DEBUG
    49         .comment 0 : { *(.comment); } :debug
    50         .debug_abbrev 0 : { *(.debug_abbrev); } :debug
    51         .debug_aranges 0 : { *(.debug_aranges); } :debug
    52         .debug_info 0 : { *(.debug_info); } :debug
    53         .debug_line 0 : { *(.debug_line); } :debug
    54         .debug_loc 0 : { *(.debug_loc); } :debug
    55         .debug_pubnames 0 : { *(.debug_pubnames); } :debug
    56         .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
    57         .debug_ranges 0 : { *(.debug_ranges); } :debug
    58         .debug_str 0 : { *(.debug_str); } :debug
    59 #endif
    6047       
    6148        /DISCARD/ : {

  • uspace/lib/c/generic/async.c

    re950803 rb366a1bc  
    430430       
    431431        fid_t fid = fibril_create(notification_fibril, msg);
    432         if (fid == 0) {
    433                 free(msg);
    434                 futex_up(&async_futex);
    435                 return false;
    436         }
    437        
    438432        fibril_add_ready(fid);
    439433       
    … …  
    687681        conn->wdata.fid = fibril_create(connection_fibril, conn);
    688682       
    689         if (conn->wdata.fid == 0) {
     683        if (!conn->wdata.fid) {
    690684                free(conn);
    691                
    692685                if (callid)
    693686                        ipc_answer_0(callid, ENOMEM);
    694                
    695687                return (uintptr_t) NULL;
    696688        }
    … …  
    861853{
    862854        fid_t fid = fibril_create(async_manager_fibril, NULL);
    863         if (fid != 0)
    864                 fibril_add_manager(fid);
     855        fibril_add_manager(fid);
    865856}
    866857

  • uspace/srv/bd/ata_bd/ata_bd.c

    re950803 rb366a1bc  
    5555#include <as.h>
    5656#include <fibril_synch.h>
    57 #include <stdint.h>
    5857#include <str.h>
    5958#include <devmap.h>
    … …  
    6261#include <errno.h>
    6362#include <bool.h>
    64 #include <byteorder.h>
    6563#include <task.h>
    6664#include <macros.h>
    … …  
    7573#define LEGACY_CTLS 4
    7674
    77 /**
    78  * Size of data returned from Identify Device or Identify Packet Device
    79  * command.
    80  */
    81 static const size_t identify_data_size = 512;
     75/** Physical block size. Should be always 512. */
     76static const size_t block_size = 512;
    8277
    8378/** Size of the communication area. */
    … …  
    110105static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt,
    111106    const void *buf);
    112 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t cnt,
     107static int ata_bd_read_block(int disk_id, uint64_t ba, size_t cnt,
    113108    void *buf);
    114 static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
     109static int ata_bd_write_block(int disk_id, uint64_t ba, size_t cnt,
    115110    const void *buf);
    116111static int disk_init(disk_t *d, int disk_id);
    117112static int drive_identify(int drive_id, void *buf);
    118 static int identify_pkt_dev(int dev_idx, void *buf);
    119 static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
    120     void *obuf, size_t obuf_size);
    121 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size);
    122 static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
    123     void *obuf, size_t obuf_size);
    124113static void disk_print_summary(disk_t *d);
    125114static int coord_calc(disk_t *d, uint64_t ba, block_coord_t *bc);
    … …  
    214203        printf("%s: ", d->model);
    215204
    216         if (d->dev_type == ata_reg_dev) {
    217                 switch (d->amode) {
    218                 case am_chs:
    219                         printf("CHS %u cylinders, %u heads, %u sectors",
    220                             disk->geom.cylinders, disk->geom.heads,
    221                             disk->geom.sectors);
    222                         break;
    223                 case am_lba28:
    224                         printf("LBA-28");
    225                         break;
    226                 case am_lba48:
    227                         printf("LBA-48");
    228                         break;
    229                 }
    230         } else {
    231                 printf("PACKET");
     205        switch (d->amode) {
     206        case am_chs:
     207                printf("CHS %u cylinders, %u heads, %u sectors",
     208                    disk->geom.cylinders, disk->geom.heads, disk->geom.sectors);
     209                break;
     210        case am_lba28:
     211                printf("LBA-28");
     212                break;
     213        case am_lba48:
     214                printf("LBA-48");
     215                break;
    232216        }
    233217
    … …  
    329313                            IPC_GET_ARG2(call));
    330314                        cnt = IPC_GET_ARG3(call);
    331                         if (cnt * disk[disk_id].block_size > comm_size) {
     315                        if (cnt * block_size > comm_size) {
    332316                                retval = ELIMIT;
    333317                                break;
    … …  
    339323                            IPC_GET_ARG2(call));
    340324                        cnt = IPC_GET_ARG3(call);
    341                         if (cnt * disk[disk_id].block_size > comm_size) {
     325                        if (cnt * block_size > comm_size) {
    342326                                retval = ELIMIT;
    343327                                break;
    … …  
    346330                        break;
    347331                case BD_GET_BLOCK_SIZE:
    348                         async_answer_1(callid, EOK, disk[disk_id].block_size);
     332                        async_answer_1(callid, EOK, block_size);
    349333                        continue;
    350334                case BD_GET_NUM_BLOCKS:
    … …  
    369353        identify_data_t idata;
    370354        uint8_t model[40];
    371         ata_inquiry_data_t inq_data;
    372355        uint16_t w;
    373356        uint8_t c;
    … …  
    376359        unsigned i;
    377360
    378         d->present = false;
    379         fibril_mutex_initialize(&d->lock);
    380 
    381         /* Try identify command. */
    382361        rc = drive_identify(disk_id, &idata);
    383         if (rc == EOK) {
    384                 /* Success. It's a register (non-packet) device. */
    385                 printf("ATA register-only device found.\n");
    386                 d->dev_type = ata_reg_dev;
    387         } else if (rc == EIO) {
    388                 /*
    389                  * There is something, but not a register device.
    390                  * It could be a packet device.
    391                  */
    392                 rc = identify_pkt_dev(disk_id, &idata);
    393                 if (rc == EOK) {
    394                         /* We have a packet device. */
    395                         d->dev_type = ata_pkt_dev;
    396                 } else {
    397                         /* Nope. Something's there, but not recognized. */
    398                         return EIO;
    399                 }
    400         } else {
    401                 /* Operation timed out. That means there is no device there. */
    402                 return EIO;
    403         }
    404 
    405         printf("device caps: 0x%04x\n", idata.caps);
    406         if (d->dev_type == ata_pkt_dev) {
    407                 /* Packet device */
    408                 d->amode = 0;
    409 
    410                 d->geom.cylinders = 0;
    411                 d->geom.heads = 0;
    412                 d->geom.sectors = 0;
    413 
    414                 d->blocks = 0;
    415         } else if ((idata.caps & rd_cap_lba) == 0) {
     362        if (rc != EOK) {
     363                d->present = false;
     364                return rc;
     365        }
     366
     367        if ((idata.caps & cap_lba) == 0) {
    416368                /* Device only supports CHS addressing. */
    417369                d->amode = am_chs;
    … …  
    470422        d->model[pos] = '\0';
    471423
    472         if (d->dev_type == ata_pkt_dev) {
    473                 /* Send inquiry. */
    474                 rc = ata_pcmd_inquiry(0, &inq_data, sizeof(inq_data));
    475                 if (rc != EOK) {
    476                         printf("Device inquiry failed.\n");
    477                         d->present = false;
    478                         return EIO;
    479                 }
    480 
    481                 /* Check device type. */
    482                 if (INQUIRY_PDEV_TYPE(inq_data.pdev_type) != PDEV_TYPE_CDROM)
    483                         printf("Warning: Peripheral device type is not CD-ROM.\n");
    484 
    485                 /* Assume 2k block size for now. */
    486                 d->block_size = 2048;
    487         } else {
    488                 /* Assume register Read always uses 512-byte blocks. */
    489                 d->block_size = 512;
    490         }
    491 
    492424        d->present = true;
     425        fibril_mutex_initialize(&d->lock);
     426
    493427        return EOK;
    494428}
    … …  
    501435
    502436        while (cnt > 0) {
    503                 if (disk[disk_id].dev_type == ata_reg_dev)
    504                         rc = ata_rcmd_read(disk_id, ba, 1, buf);
    505                 else
    506                         rc = ata_pcmd_read_12(disk_id, ba, 1, buf,
    507                             disk[disk_id].block_size);
    508 
     437                rc = ata_bd_read_block(disk_id, ba, 1, buf);
    509438                if (rc != EOK)
    510439                        return rc;
    … …  
    512441                ++ba;
    513442                --cnt;
    514                 buf += disk[disk_id].block_size;
     443                buf += block_size;
    515444        }
    516445
    … …  
    524453        int rc;
    525454
    526         if (disk[disk_id].dev_type != ata_reg_dev)
    527                 return ENOTSUP;
    528 
    529455        while (cnt > 0) {
    530                 rc = ata_rcmd_write(disk_id, ba, 1, buf);
     456                rc = ata_bd_write_block(disk_id, ba, 1, buf);
    531457                if (rc != EOK)
    532458                        return rc;
    … …  
    534460                ++ba;
    535461                --cnt;
    536                 buf += disk[disk_id].block_size;
     462                buf += block_size;
    537463        }
    538464
    … …  
    547473 * @param disk_id       Device ID, 0 or 1.
    548474 * @param buf           Pointer to a 512-byte buffer.
    549  *
    550  * @return              ETIMEOUT on timeout (this can mean the device is
    551  *                      not present). EIO if device responds with error.
    552475 */
    553476static int drive_identify(int disk_id, void *buf)
    … …  
    561484
    562485        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    563                 return ETIMEOUT;
     486                return EIO;
    564487
    565488        pio_write_8(&cmd->drive_head, drv_head);
    … …  
    570493         */
    571494        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    572                 return ETIMEOUT;
     495                return EIO;
    573496
    574497        pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
    575498
    576499        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_PROBE) != EOK)
    577                 return ETIMEOUT;
     500                return EIO;
    578501
    579502        /* Read data from the disk buffer. */
    580503
    581504        if ((status & SR_DRQ) != 0) {
    582                 for (i = 0; i < identify_data_size / 2; i++) {
     505                for (i = 0; i < block_size / 2; i++) {
    583506                        data = pio_read_16(&cmd->data_port);
    584507                        ((uint16_t *) buf)[i] = data;
    … …  
    586509        }
    587510
    588         if ((status & SR_ERR) != 0) {
    589                 return EIO;
    590         }
    591 
    592         return EOK;
    593 }
    594 
    595 /** Issue Identify Packet Device command.
    596  *
    597  * Reads @c identify data into the provided buffer. This is used to detect
    598  * whether an ATAPI device is present and if so, to determine its parameters.
    599  *
    600  * @param dev_idx       Device index, 0 or 1.
    601  * @param buf           Pointer to a 512-byte buffer.
    602  */
    603 static int identify_pkt_dev(int dev_idx, void *buf)
    604 {
    605         uint16_t data;
    606         uint8_t status;
    607         uint8_t drv_head;
    608         size_t i;
    609 
    610         drv_head = ((dev_idx != 0) ? DHR_DRV : 0);
    611 
    612         if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    613                 return EIO;
    614 
    615         pio_write_8(&cmd->drive_head, drv_head);
    616 
    617         /* For ATAPI commands we do not need to wait for DRDY. */
    618         if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    619                 return EIO;
    620 
    621         pio_write_8(&cmd->command, CMD_IDENTIFY_PKT_DEV);
    622 
    623         if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK)
    624                 return EIO;
    625 
    626         /* Read data from the device buffer. */
    627 
    628         if ((status & SR_DRQ) != 0) {
    629                 for (i = 0; i < identify_data_size / 2; i++) {
    630                         data = pio_read_16(&cmd->data_port);
    631                         ((uint16_t *) buf)[i] = data;
    632                 }
    633         }
    634 
    635511        if ((status & SR_ERR) != 0)
    636512                return EIO;
    637 
    638         return EOK;
    639 }
    640 
    641 /** Issue packet command (i. e. write a command packet to the device).
    642  *
    643  * Only data-in commands are supported (e.g. inquiry, read).
    644  *
    645  * @param dev_idx       Device index (0 or 1)
    646  * @param obuf          Buffer for storing data read from device
    647  * @param obuf_size     Size of obuf in bytes
    648  *
    649  * @return EOK on success, EIO on error.
    650  */
    651 static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
    652     void *obuf, size_t obuf_size)
    653 {
    654         size_t i;
    655         uint8_t status;
    656         uint8_t drv_head;
    657         disk_t *d;
    658         size_t data_size;
    659         uint16_t val;
    660 
    661         d = &disk[dev_idx];
    662         fibril_mutex_lock(&d->lock);
    663 
    664         /* New value for Drive/Head register */
    665         drv_head =
    666             ((dev_idx != 0) ? DHR_DRV : 0);
    667 
    668         if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK) {
    669                 fibril_mutex_unlock(&d->lock);
    670                 return EIO;
    671         }
    672 
    673         pio_write_8(&cmd->drive_head, drv_head);
    674 
    675         if (wait_status(0, ~(SR_BSY|SR_DRQ), NULL, TIMEOUT_BSY) != EOK) {
    676                 fibril_mutex_unlock(&d->lock);
    677                 return EIO;
    678         }
    679 
    680         /* Byte count <- max. number of bytes we can read in one transfer. */
    681         pio_write_8(&cmd->cylinder_low, 0xfe);
    682         pio_write_8(&cmd->cylinder_high, 0xff);
    683 
    684         pio_write_8(&cmd->command, CMD_PACKET);
    685 
    686         if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    687                 fibril_mutex_unlock(&d->lock);
    688                 return EIO;
    689         }
    690 
    691         /* Write command packet. */
    692         for (i = 0; i < (cpkt_size + 1) / 2; i++)
    693                 pio_write_16(&cmd->data_port, ((uint16_t *) cpkt)[i]);
    694 
    695         if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    696                 fibril_mutex_unlock(&d->lock);
    697                 return EIO;
    698         }
    699 
    700         if ((status & SR_DRQ) == 0) {
    701                 fibril_mutex_unlock(&d->lock);
    702                 return EIO;
    703         }
    704 
    705         /* Read byte count. */
    706         data_size = (uint16_t) pio_read_8(&cmd->cylinder_low) +
    707             ((uint16_t) pio_read_8(&cmd->cylinder_high) << 8);
    708 
    709         /* Check whether data fits into output buffer. */
    710         if (data_size > obuf_size) {
    711                 /* Output buffer is too small to store data. */
    712                 fibril_mutex_unlock(&d->lock);
    713                 return EIO;
    714         }
    715 
    716         /* Read data from the device buffer. */
    717         for (i = 0; i < (data_size + 1) / 2; i++) {
    718                 val = pio_read_16(&cmd->data_port);
    719                 ((uint16_t *) obuf)[i] = val;
    720         }
    721 
    722         if (status & SR_ERR) {
    723                 fibril_mutex_unlock(&d->lock);
    724                 return EIO;
    725         }
    726 
    727         fibril_mutex_unlock(&d->lock);
    728 
    729         return EOK;
    730 }
    731 
    732 /** Issue ATAPI Inquiry.
    733  *
    734  * @param dev_idx       Device index (0 or 1)
    735  * @param obuf          Buffer for storing inquiry data read from device
    736  * @param obuf_size     Size of obuf in bytes
    737  *
    738  * @return EOK on success, EIO on error.
    739  */
    740 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size)
    741 {
    742         ata_pcmd_inquiry_t cp;
    743         int rc;
    744 
    745         memset(&cp, 0, sizeof(cp));
    746 
    747         cp.opcode = PCMD_INQUIRY;
    748         cp.alloc_len = min(obuf_size, 0xff); /* Allocation length */
    749 
    750         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
    751         if (rc != EOK)
    752                 return rc;
    753 
    754         return EOK;
    755 }
    756 
    757 /** Issue ATAPI read(12) command.
    758  *
    759  * Output buffer must be large enough to hold the data, otherwise the
    760  * function will fail.
    761  *
    762  * @param dev_idx       Device index (0 or 1)
    763  * @param ba            Starting block address
    764  * @param cnt           Number of blocks to read
    765  * @param obuf          Buffer for storing inquiry data read from device
    766  * @param obuf_size     Size of obuf in bytes
    767  *
    768  * @return EOK on success, EIO on error.
    769  */
    770 static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
    771     void *obuf, size_t obuf_size)
    772 {
    773         ata_pcmd_read_12_t cp;
    774         int rc;
    775 
    776         if (ba > UINT32_MAX)
    777                 return EINVAL;
    778 
    779         memset(&cp, 0, sizeof(cp));
    780 
    781         cp.opcode = PCMD_READ_12;
    782         cp.ba = host2uint32_t_be(ba);
    783         cp.nblocks = host2uint32_t_be(cnt);
    784 
    785         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
    786         if (rc != EOK)
    787                 return rc;
    788513
    789514        return EOK;
    … …  
    799524 * @return EOK on success, EIO on error.
    800525 */
    801 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t blk_cnt,
     526static int ata_bd_read_block(int disk_id, uint64_t ba, size_t blk_cnt,
    802527    void *buf)
    803528{
    … …  
    854579                /* Read data from the device buffer. */
    855580
    856                 for (i = 0; i < disk[disk_id].block_size / 2; i++) {
     581                for (i = 0; i < block_size / 2; i++) {
    857582                        data = pio_read_16(&cmd->data_port);
    858583                        ((uint16_t *) buf)[i] = data;
    … …  
    876601 * @return EOK on success, EIO on error.
    877602 */
    878 static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
     603static int ata_bd_write_block(int disk_id, uint64_t ba, size_t cnt,
    879604    const void *buf)
    880605{
    … …  
    930655                /* Write data to the device buffer. */
    931656
    932                 for (i = 0; i < disk[disk_id].block_size / 2; i++) {
     657                for (i = 0; i < block_size / 2; i++) {
    933658                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    934659                }

  • uspace/srv/bd/ata_bd/ata_bd.h

    re950803 rb366a1bc  
    5353};
    5454
    55 enum ata_dev_type {
    56         ata_reg_dev,    /* Register device (no packet feature set support) */
    57         ata_pkt_dev     /* Packet device (supports packet feature set). */
    58 };
    59 
    60 /** Register device block addressing mode. */
    61 enum rd_addr_mode {
     55/** Block addressing mode. */
     56enum addr_mode {
    6257        am_chs,         /**< CHS block addressing */
    6358        am_lba28,       /**< LBA-28 block addressing */
    … …  
    6762/** Block coordinates */
    6863typedef struct {
    69         enum rd_addr_mode amode;
     64        /** Addressing mode used */
     65        enum addr_mode amode;
    7066
    7167        union {
    … …  
    9490typedef struct {
    9591        bool present;
    96 
    97         /** Device type */
    98         enum ata_dev_type dev_type;
    99 
    100         /** Addressing mode to use (if register device) */
    101         enum rd_addr_mode amode;
     92        enum addr_mode amode;
    10293
    10394        /*
    … …  
    111102
    112103        uint64_t blocks;
    113         size_t block_size;
    114104
    115105        char model[STR_BOUNDS(40) + 1];

  • uspace/srv/bd/ata_bd/ata_hw.h

    re950803 rb366a1bc  
    134134        CMD_WRITE_SECTORS       = 0x30,
    135135        CMD_WRITE_SECTORS_EXT   = 0x34,
    136         CMD_PACKET              = 0xA0,
    137         CMD_IDENTIFY_PKT_DEV    = 0xA1,
    138136        CMD_IDENTIFY_DRIVE      = 0xEC
    139137};
    140138
    141 /** Data returned from identify device and identify packet device command. */
     139/** Data returned from @c identify command. */
    142140typedef struct {
    143141        uint16_t gen_conf;
    … …  
    161159        uint16_t max_rw_multiple;
    162160        uint16_t _res48;
    163         uint16_t caps;          /* Different meaning for packet device */
     161        uint16_t caps;
    164162        uint16_t _res50;
    165163        uint16_t pio_timing;
    … …  
    216214} identify_data_t;
    217215
    218 /** Capability bits for register device. */
    219 enum ata_regdev_caps {
    220         rd_cap_iordy            = 0x0800,
    221         rd_cap_iordy_cbd        = 0x0400,
    222         rd_cap_lba              = 0x0200,
    223         rd_cap_dma              = 0x0100
    224 };
    225 
    226 /** Capability bits for packet device. */
    227 enum ata_pktdev_caps {
    228         pd_cap_ildma            = 0x8000,
    229         pd_cap_cmdqueue         = 0x4000,
    230         pd_cap_overlap          = 0x2000,
    231         pd_cap_need_softreset   = 0x1000,       /* Obsolete (ATAPI-6) */
    232         pd_cap_iordy            = 0x0800,
    233         pd_cap_iordy_dis        = 0x0400,
    234         pd_cap_lba              = 0x0200,       /* Must be on */
    235         pd_cap_dma              = 0x0100
     216enum ata_caps {
     217        cap_iordy       = 0x0800,
     218        cap_iordy_cbd   = 0x0400,
     219        cap_lba         = 0x0200,
     220        cap_dma         = 0x0100
    236221};
    237222
    … …  
    241226};
    242227
    243 /** ATA packet command codes. */
    244 enum ata_pkt_command {
    245         PCMD_INQUIRY            = 0x12,
    246         PCMD_READ_12            = 0xa8
    247 };
    248 
    249 /** ATAPI Inquiry command */
    250 typedef struct {
    251         uint8_t opcode;         /**< Operation code (PCMD_INQUIRY) */
    252         uint8_t _res0;
    253         uint8_t _res1;
    254         uint8_t _res2;
    255         uint8_t alloc_len;      /**< Allocation length */
    256         uint8_t _res3;
    257         uint8_t _res4;
    258         uint8_t _res5;
    259         uint32_t _res6;
    260 } __attribute__ ((packed)) ata_pcmd_inquiry_t;
    261 
    262 /** ATAPI Read(12) command */
    263 typedef struct {
    264         uint8_t opcode;         /**< Operation code (PCMD_READ_12) */
    265         uint8_t _res0;
    266         uint32_t ba;            /**< Starting block address */
    267         uint32_t nblocks;       /**< Number of blocks to transfer */
    268         uint8_t _res1;
    269         uint8_t _res2;
    270 } __attribute__ ((packed)) ata_pcmd_read_12_t;
    271 
    272 /** Data returned from Inquiry command (mandatory part) */
    273 typedef struct {
    274         uint8_t pdev_type;      /** Reserved, Peripheral device type */
    275         uint8_t rmb;            /** RMB, Reserved */
    276         uint8_t std_version;    /** ISO version, ECMA version, ANSI version */
    277         uint8_t atapi_ver_rdf;  /** ATAPI version, Response data format */
    278         uint8_t additional_len; /** Additional length */
    279         uint8_t _res0;
    280         uint8_t _res1;
    281         uint8_t _res2;
    282         uint8_t vendor_id[8];   /** Vendor ID */
    283         uint8_t product_id[8];  /** Product ID */
    284         uint8_t product_rev[4]; /** Product revision level */
    285 } ata_inquiry_data_t;
    286 
    287 /** Extract value of ata_inquiry_data_t.pdev_type */
    288 #define INQUIRY_PDEV_TYPE(val) ((val) & 0x1f)
    289 
    290 /** Values for ata_inquiry_data_t.pdev_type */
    291 enum ata_pdev_type {
    292         PDEV_TYPE_CDROM         = 0x05
    293 };
    294 
    295228#endif
    296229

  • uspace/srv/loader/arch/amd64/_link.ld.in

    re950803 rb366a1bc  
    1 /*
    2  * The difference from _link.ld.in for regular statically-linked apps
    3  * is the base address and the special interp section.
    4  */
    5 
    61STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    72ENTRY(__entry)
    … …  
    116        text PT_LOAD FLAGS(5);
    127        data PT_LOAD FLAGS(6);
    13         debug PT_NOTE;
    148}
    159
    … …  
    1711        .interp : {
    1812                *(.interp);
    19         } :interp
    20        
    21         /* . = 0x0000700000001000; */
     13        } : interp
     14
     15        /* . = 0x0000700000001000;*/
    2216        . = 0x70001000;
    2317       
    … …  
    2519                *(.init);
    2620        } :text
    27        
    2821        .text : {
    2922                *(.text);
    … …  
    3427                *(.data);
    3528        } :data
    36        
    3729        .tdata : {
    3830                _tdata_start = .;
    … …  
    4032                _tdata_end = .;
    4133        } :data
    42        
    4334        .tbss : {
    4435                _tbss_start = .;
    … …  
    4637                _tbss_end = .;
    4738        } :data
    48        
    4939        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    50        
    5140        .bss : {
    5241                *(COMMON);
    5342                *(.bss);
    5443        } :data
    55        
     44
    5645        . = ALIGN(0x1000);
    5746        _heap = .;
    58        
    59 #ifdef CONFIG_LINE_DEBUG
    60         .comment 0 : { *(.comment); } :debug
    61         .debug_abbrev 0 : { *(.debug_abbrev); } :debug
    62         .debug_aranges 0 : { *(.debug_aranges); } :debug
    63         .debug_info 0 : { *(.debug_info); } :debug
    64         .debug_line 0 : { *(.debug_line); } :debug
    65         .debug_loc 0 : { *(.debug_loc); } :debug
    66         .debug_pubnames 0 : { *(.debug_pubnames); } :debug
    67         .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
    68         .debug_ranges 0 : { *(.debug_ranges); } :debug
    69         .debug_str 0 : { *(.debug_str); } :debug
    70 #endif
    7147       
    7248        /DISCARD/ : {
    7349                *(*);
    7450        }
     51
    7552}

  • uspace/srv/loader/arch/ia32/_link.ld.in

    re950803 rb366a1bc  
    33 * is the base address and the special interp section.
    44 */
    5 
    65STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    76ENTRY(__entry)
    … …  
    1110        text PT_LOAD FILEHDR PHDRS FLAGS(5);
    1211        data PT_LOAD FLAGS(6);
    13         debug PT_NOTE;
    1412}
    1513
    … …  
    5553       
    5654        . = ALIGN(0x1000);
     55       
    5756        _heap = .;
    58        
    59 #ifdef CONFIG_LINE_DEBUG
    60         .comment 0 : { *(.comment); } :debug
    61         .debug_abbrev 0 : { *(.debug_abbrev); } :debug
    62         .debug_aranges 0 : { *(.debug_aranges); } :debug
    63         .debug_info 0 : { *(.debug_info); } :debug
    64         .debug_line 0 : { *(.debug_line); } :debug
    65         .debug_loc 0 : { *(.debug_loc); } :debug
    66         .debug_pubnames 0 : { *(.debug_pubnames); } :debug
    67         .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
    68         .debug_ranges 0 : { *(.debug_ranges); } :debug
    69         .debug_str 0 : { *(.debug_str); } :debug
    70 #endif
    7157       
    7258        /DISCARD/ : {

  • uspace/srv/loader/elf_load.c

    re950803 rb366a1bc  
    300300        case PT_NULL:
    301301        case PT_PHDR:
    302         case PT_NOTE:
    303302                break;
    304303        case PT_LOAD:
    … …  
    311310        case PT_DYNAMIC:
    312311        case PT_SHLIB:
     312        case PT_NOTE:
    313313        case PT_LOPROC:
    314314        case PT_HIPROC:
Note: See TracChangeset for help on using the changeset viewer.