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

Changeset 16f9782 in mainline


Ignore:
Timestamp:
2011-08-19T16:46:22Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
ab34cc9
Parents:
633bcc6 (diff), 45059d6b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Files:
2 added
35 edited
1 moved

Legend:

Unmodified
Added
Removed
  • HelenOS.config

    r633bcc6 r16f9782  
    7070@ "pentium4" Pentium 4
    7171@ "pentium3" Pentium 3
     72@ "i486" i486
    7273@ "core" Core Solo/Duo
    7374@ "athlon_xp" Athlon XP
  • abi/include/ipc/event.h

    r633bcc6 r16f9782  
    3636#define ABI_IPC_EVENT_H_
    3737
     38/** Global events */
    3839typedef enum event_type {
    3940        /** New data available in kernel log */
  • boot/Makefile.common

    r633bcc6 r16f9782  
    143143        $(USPACE_PATH)/app/blkdump/blkdump \
    144144        $(USPACE_PATH)/app/bnchmark/bnchmark \
     145        $(USPACE_PATH)/app/devctl/devctl \
    145146        $(USPACE_PATH)/app/dltest/dltest \
    146147        $(USPACE_PATH)/app/dltest2/dltest2 \
  • kernel/arch/ia32/Makefile.inc

    r633bcc6 r16f9782  
    6464endif
    6565
     66ifeq ($(PROCESSOR),i486)
     67        CMN2 = -march=i486
     68endif
     69
    6670ifeq ($(PROCESSOR),core)
    6771        CMN2 = -march=prescott
  • kernel/arch/ia32/include/asm.h

    r633bcc6 r16f9782  
    311311}
    312312
     313#ifndef PROCESSOR_i486
    313314/** Write to MSR */
    314315NO_TRACE static inline void write_msr(uint32_t msr, uint64_t value)
     
    335336        return ((uint64_t) dx << 32) | ax;
    336337}
     338#endif
    337339
    338340
  • kernel/arch/ia32/include/atomic.h

    r633bcc6 r16f9782  
    121121        asm volatile (
    122122                "0:\n"
     123#ifndef PROCESSOR_i486
    123124                "pause\n"        /* Pentium 4's HT love this instruction */
     125#endif
    124126                "mov %[count], %[tmp]\n"
    125127                "testl %[tmp], %[tmp]\n"
  • kernel/arch/ia32/include/cycle.h

    r633bcc6 r16f9782  
    4040NO_TRACE static inline uint64_t get_cycle(void)
    4141{
     42#ifdef PROCESSOR_i486
     43        return 0;
     44#else
    4245        uint64_t v;
    4346       
     
    4851       
    4952        return v;
     53#endif
    5054}
    5155
  • kernel/arch/ia32/src/asm.S

    r633bcc6 r16f9782  
    405405        xorl %eax, %eax
    406406        cmpl $(GDT_SELECTOR(KTEXT_DES)), ISTATE_OFFSET_CS(%esp)
     407#ifdef PROCESSOR_i486
     408        jz 0f
     409        movl %eax, %ebp
     4100:
     411#else
    407412        cmovnzl %eax, %ebp
     413#endif
    408414
    409415        movl %ebp, ISTATE_OFFSET_EBP_FRAME(%esp)
  • kernel/arch/ia32/src/boot/boot.S

    r633bcc6 r16f9782  
    9797        pm_status $status_prot
    9898       
    99         movl $(INTEL_CPUID_LEVEL), %eax
    100         cpuid
    101         cmp $0x0, %eax  /* any function > 0? */
    102         jbe pse_unsupported
    103        
    104         movl $(INTEL_CPUID_STANDARD), %eax
    105         cpuid
    106         bt $(INTEL_PSE), %edx
    107         jc pse_supported
    108        
    109         pse_unsupported:
    110                
    111                 pm_error $err_pse
    112        
    113         pse_supported:
    114        
    11599#include "vesa_prot.inc"
    116100       
     
    140124                jmp hlt0
    141125
     126/** Calculate unmapped address of the end of the kernel. */
     127calc_end_of_kernel:
     128        movl $hardcoded_load_address, %edi
     129        andl $0x7fffffff, %edi
     130        movl (%edi), %esi
     131        andl $0x7fffffff, %esi
     132       
     133        movl $hardcoded_ktext_size, %edi
     134        andl $0x7fffffff, %edi
     135        addl (%edi), %esi
     136        andl $0x7fffffff, %esi
     137       
     138        movl $hardcoded_kdata_size, %edi
     139        andl $0x7fffffff, %edi
     140        addl (%edi), %esi
     141        andl $0x7fffffff, %esi
     142        movl %esi, end_of_kernel
     143        ret
     144
     145/** Find free 2M (+4k for alignment) region where to store page tables */
     146find_mem_for_pt:
     147        /* Check if multiboot info is present */
     148        cmpl $0x2BADB002, grub_eax
     149        je check_multiboot_map
     150        ret
     151check_multiboot_map:
     152        /* Copy address of the multiboot info to ebx */
     153        movl grub_ebx, %ebx
     154        /* Check if memory map flag is present */
     155        movl (%ebx), %edx
     156        andl $(1 << 6), %edx
     157        jnz use_multiboot_map
     158        ret
     159use_multiboot_map:
     160        /* Copy address of the memory map to edx */
     161        movl 48(%ebx), %edx
     162        movl %edx, %ecx
     163        addl 44(%ebx), %ecx
     164        /* Find a free region at least 2M in size */
     165        check_memmap_loop:
     166                /* Is this a free region? */
     167                cmp $1, 20(%edx)
     168                jnz next_region
     169                /* Check size */
     170                cmp $0, 16(%edx)
     171                jnz next_region
     172                cmpl $(2 * 1024 * 1024 + 4 * 1024), 12(%edx)
     173                jbe next_region
     174                cmp $0, 8(%edx)
     175                jz found_region
     176        next_region:
     177                cmp %ecx, %edx
     178                jbe next_region_do
     179                ret
     180        next_region_do:
     181                addl (%edx), %edx
     182                addl $4, %edx
     183                jmp check_memmap_loop
     184        found_region:
     185                /* Use end of the found region */
     186                mov 4(%edx), %ecx
     187                add 12(%edx), %ecx
     188                sub $(2 * 1024 * 1024), %ecx
     189                mov %ecx, free_area
     190        ret
     191               
     192
    142193/** Setup mapping for the kernel.
    143194 *
     
    148199.global map_kernel
    149200map_kernel:
     201        /* Paging features */
    150202        movl %cr4, %ecx
    151         orl $(1 << 4), %ecx      /* PSE on */
    152203        andl $(~(1 << 5)), %ecx  /* PAE off */
    153204        movl %ecx, %cr4
    154205       
     206        call calc_end_of_kernel
     207        call find_mem_for_pt
     208        mov end_of_kernel, %esi
     209        mov free_area, %ecx
     210        cmpl %esi, %ecx
     211        jbe use_end_of_kernel
     212        mov %ecx, %esi
     213        /* Align address down to 4k */
     214        andl $(~4095), %esi
     215use_end_of_kernel:
     216       
     217        /* Align address to 4k */
     218        addl $4095, %esi
     219        andl $(~4095), %esi
     220       
     221        /* Allocate space for page tables*/     
     222        movl %esi, pt_loc
     223        movl $ballocs, %edi
     224        andl $0x7fffffff, %edi
     225        movl %esi, (%edi)
     226        addl $4, %edi
     227        movl $(2*1024*1024), (%edi)
     228       
     229        /* Fill page tables */
     230        xorl %ecx, %ecx
     231        xorl %ebx, %ebx
     232       
     233        floop_pt:
     234                movl $((1 << 1) | (1 << 0)), %eax
     235                orl %ebx, %eax
     236                movl %eax, (%esi, %ecx, 4)
     237                addl $(4 * 1024), %ebx
     238               
     239                incl %ecx
     240                cmpl $(512 * 1024), %ecx
     241                jl floop_pt
     242       
     243        /* Fill page directory */
    155244        movl $(page_directory + 0), %esi
    156245        movl $(page_directory + 2048), %edi
    157246        xorl %ecx, %ecx
    158         xorl %ebx, %ebx
     247        movl pt_loc, %ebx
    159248       
    160249        floop:
    161                 movl $((1 << 7) | (1 << 1) | (1 << 0)), %eax
     250                movl $((1 << 1) | (1 << 0)), %eax
    162251                orl %ebx, %eax
    163252                /* Mapping 0x00000000 + %ecx * 4M => 0x00000000 + %ecx * 4M */
     
    165254                /* Mapping 0x80000000 + %ecx * 4M => 0x00000000 + %ecx * 4M */
    166255                movl %eax, (%edi, %ecx, 4)
    167                 addl $(4 * 1024 * 1024), %ebx
     256                addl $(4 * 1024), %ebx
    168257               
    169258                incl %ecx
     
    523612
    524613grub_ebx:
     614        .long 0
     615
     616pt_loc:
     617        .long 0
     618end_of_kernel:
     619        .long 0
     620free_area:
    525621        .long 0
    526622
  • kernel/arch/ia32/src/cpu/cpu.c

    r633bcc6 r16f9782  
    118118                );
    119119        }
    120        
     120
     121#ifndef PROCESSOR_i486
    121122        if (CPU->arch.fi.bits.sep) {
    122123                /* Setup fast SYSENTER/SYSEXIT syscalls */
    123124                syscall_setup_cpu();
    124125        }
     126#endif
    125127}
    126128
  • kernel/arch/ia32/src/proc/scheduler.c

    r633bcc6 r16f9782  
    6060        uintptr_t kstk = (uintptr_t) &THREAD->kstack[STACK_SIZE];
    6161       
     62#ifndef PROCESSOR_i486
    6263        if (CPU->arch.fi.bits.sep) {
    6364                /* Set kernel stack for CP3 -> CPL0 switch via SYSENTER */
    6465                write_msr(IA32_MSR_SYSENTER_ESP, kstk - sizeof(istate_t));
    6566        }
     67#endif
    6668       
    6769        /* Set kernel stack for CPL3 -> CPL0 switch via interrupt */
  • kernel/arch/ia32/src/syscall.c

    r633bcc6 r16f9782  
    3939#include <arch/pm.h>
    4040
     41#ifndef PROCESSOR_i486
    4142/** Enable & setup support for SYSENTER/SYSEXIT */
    4243void syscall_setup_cpu(void)
     
    4950        write_msr(IA32_MSR_SYSENTER_EIP, (uint32_t) sysenter_handler);
    5051}
     52#endif
    5153
    5254/** @}
  • kernel/generic/include/ipc/event.h

    r633bcc6 r16f9782  
    4141#include <ipc/ipc.h>
    4242
    43 typedef struct task task_t;
     43struct task;
    4444
    4545typedef void (*event_callback_t)(void *);
     
    6363
    6464extern void event_init(void);
    65 extern void event_task_init(task_t *);
     65extern void event_task_init(struct task *);
    6666extern void event_cleanup_answerbox(answerbox_t *);
    6767extern void event_set_unmask_callback(event_type_t, event_callback_t);
    68 extern void event_task_set_unmask_callback(task_t *, event_task_type_t,
     68extern void event_task_set_unmask_callback(struct task *, event_task_type_t,
    6969    event_callback_t);
    7070
     
    9797extern int event_notify(event_type_t, bool, sysarg_t, sysarg_t, sysarg_t,
    9898    sysarg_t, sysarg_t);
    99 extern int event_task_notify(task_t *, event_task_type_t, bool, sysarg_t, sysarg_t,
     99extern int event_task_notify(struct task *, event_task_type_t, bool, sysarg_t, sysarg_t,
    100100    sysarg_t, sysarg_t, sysarg_t);
    101101
  • kernel/generic/src/console/console.c

    r633bcc6 r16f9782  
    248248}
    249249
    250 void klog_update(void *e)
     250void klog_update(void *event)
    251251{
    252252        if (!atomic_get(&klog_inited))
  • kernel/generic/src/ipc/event.c

    r633bcc6 r16f9782  
    8181}
    8282
    83 void event_task_init(task_t *t)
     83void event_task_init(task_t *task)
    8484{
    8585        for (unsigned int i = EVENT_END; i < EVENT_TASK_END; i++)
    86                 event_initialize(evno2event(i, t));
     86                event_initialize(evno2event(i, task));
    8787}
    8888
     
    130130}
    131131
    132 void event_task_set_unmask_callback(task_t *t, event_task_type_t evno,
     132void event_task_set_unmask_callback(task_t *task, event_task_type_t evno,
    133133    event_callback_t callback)
    134134{
     
    136136        ASSERT(evno < EVENT_TASK_END);
    137137               
    138         _event_set_unmask_callback(evno2event(evno, t), callback);
     138        _event_set_unmask_callback(evno2event(evno, task), callback);
    139139}
    140140
     
    213213/** Send per-task kernel notification event
    214214 *
    215  * @param t    Destination task.
     215 * @param task Destination task.
    216216 * @param evno Event type.
    217217 * @param mask Mask further notifications after a successful
     
    231231 *
    232232 */
    233 int event_task_notify(task_t *t, event_task_type_t evno, bool mask, sysarg_t a1,
    234     sysarg_t a2, sysarg_t a3, sysarg_t a4, sysarg_t a5)
     233int event_task_notify(task_t *task, event_task_type_t evno, bool mask,
     234    sysarg_t a1, sysarg_t a2, sysarg_t a3, sysarg_t a4, sysarg_t a5)
    235235{
    236236        ASSERT(evno >= (int) EVENT_END);
    237237        ASSERT(evno < EVENT_TASK_END);
    238238       
    239         return event_enqueue(evno2event(evno, t), mask, a1, a2, a3, a4, a5);
     239        return event_enqueue(evno2event(evno, task), mask, a1, a2, a3, a4, a5);
    240240}
    241241
  • uspace/Makefile

    r633bcc6 r16f9782  
    3737        app/blkdump \
    3838        app/bnchmark \
     39        app/devctl \
    3940        app/edit \
    4041        app/ext2info \
  • uspace/app/lsusb/main.c

    r633bcc6 r16f9782  
    8181                }
    8282                char path[MAX_PATH_LENGTH];
    83                 rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
     83                rc = devman_fun_get_path(dev_handle, path, MAX_PATH_LENGTH);
    8484                if (rc != EOK) {
    8585                        continue;
     
    120120                }
    121121                char path[MAX_PATH_LENGTH];
    122                 rc = devman_get_device_path(hc_handle, path, MAX_PATH_LENGTH);
     122                rc = devman_fun_get_path(hc_handle, path, MAX_PATH_LENGTH);
    123123                if (rc != EOK) {
    124124                        printf(NAME ": Error resolving path of HC with SID %"
  • uspace/app/mkbd/main.c

    r633bcc6 r16f9782  
    240240       
    241241        char path[MAX_PATH_LENGTH];
    242         rc = devman_get_device_path(dev_handle, path, MAX_PATH_LENGTH);
     242        rc = devman_fun_get_path(dev_handle, path, MAX_PATH_LENGTH);
    243243        if (rc != EOK) {
    244244                return ENOMEM;
  • uspace/app/tester/hw/serial/serial1.c

    r633bcc6 r16f9782  
    7272       
    7373        devman_handle_t handle;
    74         int res = devman_device_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
     74        int res = devman_fun_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
    7575            IPC_FLAG_BLOCKING);
    7676        if (res != EOK)
  • uspace/lib/c/arch/ia32/Makefile.common

    r633bcc6 r16f9782  
    2828
    2929CLANG_ARCH = i386
     30ifeq ($(PROCESSOR),i486)
     31GCC_CFLAGS += -march=i486 -fno-omit-frame-pointer
     32else
    3033GCC_CFLAGS += -march=pentium -fno-omit-frame-pointer
     34endif
    3135
    3236ENDIANESS = LE
  • uspace/lib/c/arch/ia32/Makefile.inc

    r633bcc6 r16f9782  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/entry.s \
     30        arch/$(UARCH)/src/entry.S \
    3131        arch/$(UARCH)/src/entryjmp.s \
    3232        arch/$(UARCH)/src/thread_entry.s \
  • uspace/lib/c/arch/ia32/src/entry.S

    r633bcc6 r16f9782  
    4646        mov %ax, %fs
    4747        # Do not set %gs, it contains descriptor that can see TLS
    48        
     48
     49#ifndef PROCESSOR_i486 
    4950        # Detect the mechanism used for making syscalls
    5051        movl $(INTEL_CPUID_STANDARD), %eax
     
    5556        movl $__syscall_fast, (%eax)
    56570:
     58#endif
    5759        #
    5860        # Create the first stack frame.
  • uspace/lib/c/generic/async.c

    r633bcc6 r16f9782  
    139139        link_t link;
    140140       
    141         sysarg_t in_task_id;
     141        task_id_t in_task_id;
    142142        atomic_t refcnt;
    143143        void *data;
  • uspace/lib/c/generic/devman.c

    r633bcc6 r16f9782  
    11/*
    22 * Copyright (c) 2007 Josef Cejka
    3  * Copyright (c) 2009 Jiri Svoboda
     3 * Copyright (c) 2011 Jiri Svoboda
    44 * Copyright (c) 2010 Lenka Trochtova
    55 * All rights reserved.
     
    195195       
    196196        exch = devman_exchange_begin(DEVMAN_DRIVER);
    197         async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
     197        async_connect_to_me(exch, 0, 0, 0, conn, NULL);
    198198        devman_exchange_end(exch);
    199199       
     
    342342}
    343343
    344 int devman_device_get_handle(const char *pathname, devman_handle_t *handle,
     344int devman_fun_get_handle(const char *pathname, devman_handle_t *handle,
    345345    unsigned int flags)
    346346{
     
    383383}
    384384
    385 int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
     385static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf,
     386    size_t buf_size)
     387{
     388        async_exch_t *exch;
     389        ipc_call_t dreply;
     390        size_t act_size;
     391        sysarg_t dretval;
     392       
     393        exch = devman_exchange_begin_blocking(LOC_PORT_CONSUMER);
     394       
     395        ipc_call_t answer;
     396        aid_t req = async_send_1(exch, method, arg1, &answer);
     397        aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
     398        async_wait_for(dreq, &dretval);
     399       
     400        devman_exchange_end(exch);
     401       
     402        if (dretval != EOK) {
     403                async_wait_for(req, NULL);
     404                return dretval;
     405        }
     406       
     407        sysarg_t retval;
     408        async_wait_for(req, &retval);
     409       
     410        if (retval != EOK)
     411                return retval;
     412       
     413        act_size = IPC_GET_ARG2(dreply);
     414        assert(act_size <= buf_size - 1);
     415        buf[act_size] = '\0';
     416       
     417        return EOK;
     418}
     419
     420int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size)
     421{
     422        return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf,
     423            buf_size);
     424}
     425
     426int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size)
     427{
     428        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
     429            buf_size);
     430}
     431
     432static int devman_get_handles_once(sysarg_t method, sysarg_t arg1,
     433    devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
     434{
     435        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
     436
     437        ipc_call_t answer;
     438        aid_t req = async_send_1(exch, method, arg1, &answer);
     439        int rc = async_data_read_start(exch, handle_buf, buf_size);
     440       
     441        devman_exchange_end(exch);
     442       
     443        if (rc != EOK) {
     444                async_wait_for(req, NULL);
     445                return rc;
     446        }
     447       
     448        sysarg_t retval;
     449        async_wait_for(req, &retval);
     450       
     451        if (retval != EOK) {
     452                return retval;
     453        }
     454       
     455        *act_size = IPC_GET_ARG1(answer);
     456        return EOK;
     457}
     458
     459/** Get list of handles.
     460 *
     461 * Returns an allocated array of handles.
     462 *
     463 * @param method        IPC method
     464 * @param arg1          IPC argument 1
     465 * @param data          Place to store pointer to array of handles
     466 * @param count         Place to store number of handles
     467 * @return              EOK on success or negative error code
     468 */
     469static int devman_get_handles_internal(sysarg_t method, sysarg_t arg1,
     470    devman_handle_t **data, size_t *count)
     471{
     472        devman_handle_t *handles;
     473        size_t act_size;
     474        size_t alloc_size;
     475        int rc;
     476
     477        *data = NULL;
     478        act_size = 0;   /* silence warning */
     479
     480        rc = devman_get_handles_once(method, arg1, NULL, 0,
     481            &act_size);
     482        if (rc != EOK)
     483                return rc;
     484
     485        alloc_size = act_size;
     486        handles = malloc(alloc_size);
     487        if (handles == NULL)
     488                return ENOMEM;
     489
     490        while (true) {
     491                rc = devman_get_handles_once(method, arg1, handles, alloc_size,
     492                    &act_size);
     493                if (rc != EOK)
     494                        return rc;
     495
     496                if (act_size <= alloc_size)
     497                        break;
     498
     499                alloc_size *= 2;
     500                free(handles);
     501
     502                handles = malloc(alloc_size);
     503                if (handles == NULL)
     504                        return ENOMEM;
     505        }
     506
     507        *count = act_size / sizeof(devman_handle_t);
     508        *data = handles;
     509        return EOK;
     510}
     511
     512int devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh)
    386513{
    387514        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     
    389516                return ENOMEM;
    390517       
    391         ipc_call_t answer;
    392         aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_DEVICE_PATH,
    393             handle, &answer);
    394        
    395         ipc_call_t data_request_call;
    396         aid_t data_request = async_data_read(exch, path, path_size,
    397             &data_request_call);
    398        
    399         devman_exchange_end(exch);
    400        
    401         if (data_request == 0) {
    402                 async_wait_for(req, NULL);
    403                 return ENOMEM;
    404         }
    405        
    406         sysarg_t data_request_rc;
    407         async_wait_for(data_request, &data_request_rc);
    408        
    409         sysarg_t opening_request_rc;
    410         async_wait_for(req, &opening_request_rc);
    411        
    412         if (data_request_rc != EOK) {
    413                 /* Prefer the return code of the opening request. */
    414                 if (opening_request_rc != EOK)
    415                         return (int) opening_request_rc;
    416                 else
    417                         return (int) data_request_rc;
    418         }
    419        
    420         if (opening_request_rc != EOK)
    421                 return (int) opening_request_rc;
    422        
    423         /* To be on the safe-side. */
    424         path[path_size - 1] = 0;
    425         size_t transferred_size = IPC_GET_ARG2(data_request_call);
    426         if (transferred_size >= path_size)
    427                 return ELIMIT;
    428        
    429         /* Terminate the string (trailing 0 not send over IPC). */
    430         path[transferred_size] = 0;
    431         return EOK;
     518        sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
     519            funh, devh);
     520       
     521        devman_exchange_end(exch);
     522        return (int) retval;
     523}
     524
     525int devman_dev_get_functions(devman_handle_t devh, devman_handle_t **funcs,
     526    size_t *count)
     527{
     528        return devman_get_handles_internal(DEVMAN_DEV_GET_FUNCTIONS,
     529            devh, funcs, count);
    432530}
    433531
  • uspace/lib/c/generic/io/printf_core.c

    r633bcc6 r16f9782  
    206206        }
    207207       
    208         return (int) (counter + 1);
     208        return (int) (counter);
    209209}
    210210
     
    244244        }
    245245       
    246         return (int) (counter + 1);
     246        return (int) (counter);
    247247}
    248248
  • uspace/lib/c/generic/loader.c

    r633bcc6 r16f9782  
    263263       
    264264        int i;
    265         for (i = 0; files[i]; i++)
    266                 ;
     265        for (i = 0; files[i]; i++);
    267266
    268267        ipc_call_t answer;
  • uspace/lib/c/generic/loc.c

    r633bcc6 r16f9782  
    315315/** Register new service.
    316316 *
    317  * @param fqsn  Fully qualified service name
    318  * @param sid   Output: ID of new service
     317 * @param fqsn Fully qualified service name
     318 * @param sid  Output: ID of new service
    319319 *
    320320 */
  • uspace/lib/c/include/devman.h

    r633bcc6 r16f9782  
    5656    unsigned int);
    5757
    58 extern int devman_device_get_handle(const char *, devman_handle_t *,
     58extern int devman_fun_get_handle(const char *, devman_handle_t *,
    5959    unsigned int);
    60 extern int devman_get_device_path(devman_handle_t, char *, size_t);
     60extern int devman_fun_get_child(devman_handle_t, devman_handle_t *);
     61extern int devman_dev_get_functions(devman_handle_t, devman_handle_t **,
     62    size_t *);
     63extern int devman_fun_get_name(devman_handle_t, char *, size_t);
     64extern int devman_fun_get_path(devman_handle_t, char *, size_t);
    6165
    6266extern int devman_add_device_to_category(devman_handle_t, const char *);
  • uspace/lib/c/include/ipc/devman.h

    r633bcc6 r16f9782  
    149149typedef enum {
    150150        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
    151         DEVMAN_DEVICE_GET_DEVICE_PATH,
     151        DEVMAN_DEV_GET_FUNCTIONS,
     152        DEVMAN_FUN_GET_CHILD,
     153        DEVMAN_FUN_GET_NAME,
     154        DEVMAN_FUN_GET_PATH,
    152155        DEVMAN_FUN_SID_TO_HANDLE
    153156} client_to_devman_t;
  • uspace/lib/drv/generic/driver.c

    r633bcc6 r16f9782  
    428428static void driver_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    429429{
     430        sysarg_t conn_type;
     431
     432        if (iid == 0) {
     433                /* Callback connection from devman */
     434                /* XXX Use separate handler for this type of connection */
     435                conn_type = DRIVER_DEVMAN;
     436        } else {
     437                conn_type = IPC_GET_ARG1(*icall);
     438        }
     439
    430440        /* Select interface */
    431         switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
     441        switch (conn_type) {
    432442        case DRIVER_DEVMAN:
    433443                /* Handle request from device manager */
  • uspace/lib/usb/src/resolve.c

    r633bcc6 r16f9782  
    152152                if (str_length(func_start) > 0) {
    153153                        char tmp_path[MAX_DEVICE_PATH ];
    154                         rc = devman_get_device_path(dev_handle,
     154                        rc = devman_fun_get_path(dev_handle,
    155155                            tmp_path, MAX_DEVICE_PATH);
    156156                        if (rc != EOK) {
     
    173173
    174174        /* First try to get the device handle. */
    175         rc = devman_device_get_handle(path, &dev_handle, 0);
     175        rc = devman_fun_get_handle(path, &dev_handle, 0);
    176176        if (rc != EOK) {
    177177                free(path);
     
    184184                /* Get device handle first. */
    185185                devman_handle_t tmp_handle;
    186                 rc = devman_device_get_handle(path, &tmp_handle, 0);
     186                rc = devman_fun_get_handle(path, &tmp_handle, 0);
    187187                if (rc != EOK) {
    188188                        free(path);
  • uspace/lib/usbvirt/src/device.c

    r633bcc6 r16f9782  
    8787       
    8888        devman_handle_t handle;
    89         int rc = devman_device_get_handle(vhc_path, &handle, 0);
     89        int rc = devman_fun_get_handle(vhc_path, &handle, 0);
    9090        if (rc != EOK)
    9191                return rc;
  • uspace/srv/devman/devman.c

    r633bcc6 r16f9782  
    548548
    549549        fibril_mutex_lock(&driver->driver_mutex);
    550        
    551         async_exch_t *exch = async_exchange_begin(driver->sess);
    552         async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE, exch,
    553             DRIVER_DEVMAN, 0, 0);
    554         async_exchange_end(exch);
    555 
    556         if (!sess) {
    557                 fibril_mutex_unlock(&driver->driver_mutex);
    558                 return;
    559         }
    560550
    561551        /*
     
    583573                fibril_mutex_unlock(&driver->driver_mutex);
    584574
    585                 add_device(sess, driver, dev, tree);
     575                add_device(driver, dev, tree);
    586576
    587577                /*
     
    603593                link = driver->devices.head.next;
    604594        }
    605 
    606         async_hangup(sess);
    607595
    608596        /*
     
    718706 * @param node          The device's node in the device tree.
    719707 */
    720 void add_device(async_sess_t *sess, driver_t *drv, dev_node_t *dev,
    721     dev_tree_t *tree)
     708void add_device(driver_t *drv, dev_node_t *dev, dev_tree_t *tree)
    722709{
    723710        /*
     
    736723        }
    737724       
    738         async_exch_t *exch = async_exchange_begin(sess);
     725        async_exch_t *exch = async_exchange_begin(drv->sess);
    739726       
    740727        ipc_call_t answer;
     
    806793        fibril_mutex_unlock(&drv->driver_mutex);
    807794
    808         if (is_running) {
    809                 /* Notify the driver about the new device. */
    810                 async_exch_t *exch = async_exchange_begin(drv->sess);
    811                 async_sess_t *sess = async_connect_me_to(EXCHANGE_SERIALIZE, exch,
    812                     DRIVER_DEVMAN, 0, 0);
    813                 async_exchange_end(exch);
    814                
    815                 if (sess) {
    816                         add_device(sess, drv, dev, tree);
    817                         async_hangup(sess);
    818                 }
    819         }
     795        /* Notify the driver about the new device. */
     796        if (is_running)
     797                add_device(drv, dev, tree);
    820798       
    821799        return true;
     
    919897        return dev;
    920898}
     899
     900/** Get list of device functions. */
     901int dev_get_functions(dev_tree_t *tree, dev_node_t *dev,
     902    devman_handle_t *hdl_buf, size_t buf_size, size_t *act_size)
     903{
     904        size_t act_cnt;
     905        size_t buf_cnt;
     906
     907        assert(fibril_rwlock_is_locked(&tree->rwlock));
     908
     909        buf_cnt = buf_size / sizeof(devman_handle_t);
     910
     911        act_cnt = list_count(&dev->functions);
     912        *act_size = act_cnt * sizeof(devman_handle_t);
     913
     914        if (buf_size % sizeof(devman_handle_t) != 0)
     915                return EINVAL;
     916
     917        size_t pos = 0;
     918        list_foreach(dev->functions, item) {
     919                fun_node_t *fun =
     920                    list_get_instance(item, fun_node_t, dev_functions);
     921
     922                if (pos < buf_cnt)
     923                        hdl_buf[pos] = fun->handle;
     924                pos++;
     925        }
     926
     927        return EOK;
     928}
     929
    921930
    922931/* Function nodes */
     
    11451154        char *rel_path = path;
    11461155        char *next_path_elem = NULL;
    1147         bool cont = true;
     1156        bool cont = (rel_path[1] != '\0');
    11481157       
    11491158        while (cont && fun != NULL) {
  • uspace/srv/devman/devman.h

    r633bcc6 r16f9782  
    235235extern void add_driver(driver_list_t *, driver_t *);
    236236extern void attach_driver(dev_node_t *, driver_t *);
    237 extern void add_device(async_sess_t *, driver_t *, dev_node_t *, dev_tree_t *);
     237extern void add_device(driver_t *, dev_node_t *, dev_tree_t *);
    238238extern bool start_driver(driver_t *);
    239239
     
    253253extern dev_node_t *find_dev_node(dev_tree_t *tree, devman_handle_t handle);
    254254extern dev_node_t *find_dev_function(dev_node_t *, const char *);
     255extern int dev_get_functions(dev_tree_t *tree, dev_node_t *, devman_handle_t *,
     256    size_t, size_t *);
    255257
    256258extern fun_node_t *create_fun_node(void);
  • uspace/srv/devman/main.c

    r633bcc6 r16f9782  
    497497}
    498498
    499 /** Find device path by its handle. */
    500 static void devman_get_device_path_by_handle(ipc_callid_t iid,
    501     ipc_call_t *icall)
     499/** Get device name. */
     500static void devman_fun_get_name(ipc_callid_t iid, ipc_call_t *icall)
    502501{
    503502        devman_handle_t handle = IPC_GET_ARG1(*icall);
     
    523522        }
    524523
     524        size_t sent_length = str_size(fun->name);
     525        if (sent_length > data_len) {
     526                sent_length = data_len;
     527        }
     528
     529        async_data_read_finalize(data_callid, fun->name, sent_length);
     530        async_answer_0(iid, EOK);
     531
     532        free(buffer);
     533}
     534
     535
     536/** Get device path. */
     537static void devman_fun_get_path(ipc_callid_t iid, ipc_call_t *icall)
     538{
     539        devman_handle_t handle = IPC_GET_ARG1(*icall);
     540
     541        fun_node_t *fun = find_fun_node(&device_tree, handle);
     542        if (fun == NULL) {
     543                async_answer_0(iid, ENOMEM);
     544                return;
     545        }
     546
     547        ipc_callid_t data_callid;
     548        size_t data_len;
     549        if (!async_data_read_receive(&data_callid, &data_len)) {
     550                async_answer_0(iid, EINVAL);
     551                return;
     552        }
     553
     554        void *buffer = malloc(data_len);
     555        if (buffer == NULL) {
     556                async_answer_0(data_callid, ENOMEM);
     557                async_answer_0(iid, ENOMEM);
     558                return;
     559        }
     560
    525561        size_t sent_length = str_size(fun->pathname);
    526562        if (sent_length > data_len) {
     
    532568
    533569        free(buffer);
     570}
     571
     572static void devman_dev_get_functions(ipc_callid_t iid, ipc_call_t *icall)
     573{
     574        ipc_callid_t callid;
     575        size_t size;
     576        size_t act_size;
     577        int rc;
     578       
     579        if (!async_data_read_receive(&callid, &size)) {
     580                async_answer_0(callid, EREFUSED);
     581                async_answer_0(iid, EREFUSED);
     582                return;
     583        }
     584       
     585        fibril_rwlock_read_lock(&device_tree.rwlock);
     586       
     587        dev_node_t *dev = find_dev_node_no_lock(&device_tree,
     588            IPC_GET_ARG1(*icall));
     589        if (dev == NULL) {
     590                fibril_rwlock_read_unlock(&device_tree.rwlock);
     591                async_answer_0(callid, ENOENT);
     592                async_answer_0(iid, ENOENT);
     593                return;
     594        }
     595       
     596        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
     597        if (hdl_buf == NULL) {
     598                fibril_rwlock_read_unlock(&device_tree.rwlock);
     599                async_answer_0(callid, ENOMEM);
     600                async_answer_0(iid, ENOMEM);
     601                return;
     602        }
     603       
     604        rc = dev_get_functions(&device_tree, dev, hdl_buf, size, &act_size);
     605        if (rc != EOK) {
     606                fibril_rwlock_read_unlock(&device_tree.rwlock);
     607                async_answer_0(callid, rc);
     608                async_answer_0(iid, rc);
     609                return;
     610        }
     611       
     612        fibril_rwlock_read_unlock(&device_tree.rwlock);
     613       
     614        sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
     615        free(hdl_buf);
     616       
     617        async_answer_1(iid, retval, act_size);
     618}
     619
     620
     621/** Get handle for child device of a function. */
     622static void devman_fun_get_child(ipc_callid_t iid, ipc_call_t *icall)
     623{
     624        fun_node_t *fun;
     625       
     626        fibril_rwlock_read_lock(&device_tree.rwlock);
     627       
     628        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
     629        if (fun == NULL) {
     630                fibril_rwlock_read_unlock(&device_tree.rwlock);
     631                async_answer_0(iid, ENOENT);
     632                return;
     633        }
     634       
     635        if (fun->child == NULL) {
     636                fibril_rwlock_read_unlock(&device_tree.rwlock);
     637                async_answer_0(iid, ENOENT);
     638                return;
     639        }
     640       
     641        async_answer_1(iid, EOK, fun->child->handle);
     642       
     643        fibril_rwlock_read_unlock(&device_tree.rwlock);
    534644}
    535645
     
    566676                        devman_function_get_handle(callid, &call);
    567677                        break;
    568                 case DEVMAN_DEVICE_GET_DEVICE_PATH:
    569                         devman_get_device_path_by_handle(callid, &call);
     678                case DEVMAN_DEV_GET_FUNCTIONS:
     679                        devman_dev_get_functions(callid, &call);
     680                        break;
     681                case DEVMAN_FUN_GET_CHILD:
     682                        devman_fun_get_child(callid, &call);
     683                        break;
     684                case DEVMAN_FUN_GET_NAME:
     685                        devman_fun_get_name(callid, &call);
     686                        break;
     687                case DEVMAN_FUN_GET_PATH:
     688                        devman_fun_get_path(callid, &call);
    570689                        break;
    571690                case DEVMAN_FUN_SID_TO_HANDLE:
  • uspace/srv/vfs/vfs.c

    r633bcc6 r16f9782  
    5353#define NAME  "vfs"
    5454
     55enum {
     56        VFS_TASK_STATE_CHANGE
     57};
     58
    5559static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    5660{
     
    134138         */
    135139}
    136 
    137 enum {
    138         VFS_TASK_STATE_CHANGE
    139 };
    140140
    141141static void notification_received(ipc_callid_t callid, ipc_call_t *call)
Note: See TracChangeset for help on using the changeset viewer.