diff options
| author | Kimplul <kimi.h.kuparinen@gmail.com> | 2022-04-10 15:39:41 +0300 |
|---|---|---|
| committer | Kimplul <kimi.h.kuparinen@gmail.com> | 2022-04-10 15:42:04 +0300 |
| commit | 8aa17b12f29536ea9c8b6ca22c7f153e8d90fa3b (patch) | |
| tree | e7dba9b6b9cdcd1d04cba639c8f76e9685ac549f | |
| parent | 4760462d9b3bf2aba8664c57be85f4adbfa164a2 (diff) | |
| download | kmi-8aa17b12f29536ea9c8b6ca22c7f153e8d90fa3b.tar.gz kmi-8aa17b12f29536ea9c8b6ca22c7f153e8d90fa3b.zip | |
add clang format and run it
48 files changed, 1764 insertions, 1121 deletions
diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..48d0867 --- /dev/null +++ b/.clang-format @@ -0,0 +1,563 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# clang-format configuration file. Intended for clang-format >= 4. +# +# For more information, see: +# +# Documentation/process/clang-format.rst +# https://clang.llvm.org/docs/ClangFormat.html +# https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +--- +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignConsecutiveMacros: AcrossEmptyLinesAndComments + +#AlignEscapedNewlines: Left # Unknown to clang-format-4.0 +AlignOperands: true +AlignTrailingComments: false +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: false +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: true + AfterNamespace: true + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + #AfterExternBlock: false # Unknown to clang-format-5.0 + BeforeCatch: false + BeforeElse: false + IndentBraces: false + #SplitEmptyFunction: true # Unknown to clang-format-4.0 + #SplitEmptyRecord: true # Unknown to clang-format-4.0 + #SplitEmptyNamespace: true # Unknown to clang-format-4.0 +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Custom +#BreakBeforeInheritanceComma: false # Unknown to clang-format-4.0 +BreakBeforeTernaryOperators: false +BreakConstructorInitializersBeforeComma: false +#BreakConstructorInitializers: BeforeComma # Unknown to clang-format-4.0 +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: false +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +#CompactNamespaces: false # Unknown to clang-format-4.0 +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 8 +ContinuationIndentWidth: 8 +Cpp11BracedListStyle: false +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +#FixNamespaceComments: false # Unknown to clang-format-4.0 + +# Taken from: +# git grep -h '^#define [^[:space:]]*for_each[^[:space:]]*(' include/ \ +# | sed "s,^#define \([^[:space:]]*for_each[^[:space:]]*\)(.*$, - '\1'," \ +# | sort | uniq +ForEachMacros: + - 'apei_estatus_for_each_section' + - 'ata_for_each_dev' + - 'ata_for_each_link' + - '__ata_qc_for_each' + - 'ata_qc_for_each' + - 'ata_qc_for_each_raw' + - 'ata_qc_for_each_with_internal' + - 'ax25_for_each' + - 'ax25_uid_for_each' + - '__bio_for_each_bvec' + - 'bio_for_each_bvec' + - 'bio_for_each_bvec_all' + - 'bio_for_each_integrity_vec' + - '__bio_for_each_segment' + - 'bio_for_each_segment' + - 'bio_for_each_segment_all' + - 'bio_list_for_each' + - 'bip_for_each_vec' + - 'bitmap_for_each_clear_region' + - 'bitmap_for_each_set_region' + - 'blkg_for_each_descendant_post' + - 'blkg_for_each_descendant_pre' + - 'blk_queue_for_each_rl' + - 'bond_for_each_slave' + - 'bond_for_each_slave_rcu' + - 'bpf_for_each_spilled_reg' + - 'btree_for_each_safe128' + - 'btree_for_each_safe32' + - 'btree_for_each_safe64' + - 'btree_for_each_safel' + - 'card_for_each_dev' + - 'cgroup_taskset_for_each' + - 'cgroup_taskset_for_each_leader' + - 'cpufreq_for_each_entry' + - 'cpufreq_for_each_entry_idx' + - 'cpufreq_for_each_valid_entry' + - 'cpufreq_for_each_valid_entry_idx' + - 'css_for_each_child' + - 'css_for_each_descendant_post' + - 'css_for_each_descendant_pre' + - 'device_for_each_child_node' + - 'displayid_iter_for_each' + - 'dma_fence_chain_for_each' + - 'do_for_each_ftrace_op' + - 'drm_atomic_crtc_for_each_plane' + - 'drm_atomic_crtc_state_for_each_plane' + - 'drm_atomic_crtc_state_for_each_plane_state' + - 'drm_atomic_for_each_plane_damage' + - 'drm_client_for_each_connector_iter' + - 'drm_client_for_each_modeset' + - 'drm_connector_for_each_possible_encoder' + - 'drm_for_each_bridge_in_chain' + - 'drm_for_each_connector_iter' + - 'drm_for_each_crtc' + - 'drm_for_each_crtc_reverse' + - 'drm_for_each_encoder' + - 'drm_for_each_encoder_mask' + - 'drm_for_each_fb' + - 'drm_for_each_legacy_plane' + - 'drm_for_each_plane' + - 'drm_for_each_plane_mask' + - 'drm_for_each_privobj' + - 'drm_mm_for_each_hole' + - 'drm_mm_for_each_node' + - 'drm_mm_for_each_node_in_range' + - 'drm_mm_for_each_node_safe' + - 'flow_action_for_each' + - 'for_each_acpi_dev_match' + - 'for_each_active_dev_scope' + - 'for_each_active_drhd_unit' + - 'for_each_active_iommu' + - 'for_each_aggr_pgid' + - 'for_each_available_child_of_node' + - 'for_each_bio' + - 'for_each_board_func_rsrc' + - 'for_each_bvec' + - 'for_each_card_auxs' + - 'for_each_card_auxs_safe' + - 'for_each_card_components' + - 'for_each_card_dapms' + - 'for_each_card_pre_auxs' + - 'for_each_card_prelinks' + - 'for_each_card_rtds' + - 'for_each_card_rtds_safe' + - 'for_each_card_widgets' + - 'for_each_card_widgets_safe' + - 'for_each_cgroup_storage_type' + - 'for_each_child_of_node' + - 'for_each_clear_bit' + - 'for_each_clear_bit_from' + - 'for_each_cmsghdr' + - 'for_each_compatible_node' + - 'for_each_component_dais' + - 'for_each_component_dais_safe' + - 'for_each_comp_order' + - 'for_each_console' + - 'for_each_cpu' + - 'for_each_cpu_and' + - 'for_each_cpu_not' + - 'for_each_cpu_wrap' + - 'for_each_dapm_widgets' + - 'for_each_dev_addr' + - 'for_each_dev_scope' + - 'for_each_dma_cap_mask' + - 'for_each_dpcm_be' + - 'for_each_dpcm_be_rollback' + - 'for_each_dpcm_be_safe' + - 'for_each_dpcm_fe' + - 'for_each_drhd_unit' + - 'for_each_dss_dev' + - 'for_each_dtpm_table' + - 'for_each_efi_memory_desc' + - 'for_each_efi_memory_desc_in_map' + - 'for_each_element' + - 'for_each_element_extid' + - 'for_each_element_id' + - 'for_each_endpoint_of_node' + - 'for_each_evictable_lru' + - 'for_each_fib6_node_rt_rcu' + - 'for_each_fib6_walker_rt' + - 'for_each_free_mem_pfn_range_in_zone' + - 'for_each_free_mem_pfn_range_in_zone_from' + - 'for_each_free_mem_range' + - 'for_each_free_mem_range_reverse' + - 'for_each_func_rsrc' + - 'for_each_hstate' + - 'for_each_if' + - 'for_each_iommu' + - 'for_each_ip_tunnel_rcu' + - 'for_each_irq_nr' + - 'for_each_link_codecs' + - 'for_each_link_cpus' + - 'for_each_link_platforms' + - 'for_each_lru' + - 'for_each_matching_node' + - 'for_each_matching_node_and_match' + - 'for_each_member' + - 'for_each_memcg_cache_index' + - 'for_each_mem_pfn_range' + - '__for_each_mem_range' + - 'for_each_mem_range' + - '__for_each_mem_range_rev' + - 'for_each_mem_range_rev' + - 'for_each_mem_region' + - 'for_each_migratetype_order' + - 'for_each_msi_entry' + - 'for_each_msi_entry_safe' + - 'for_each_msi_vector' + - 'for_each_net' + - 'for_each_net_continue_reverse' + - 'for_each_netdev' + - 'for_each_netdev_continue' + - 'for_each_netdev_continue_rcu' + - 'for_each_netdev_continue_reverse' + - 'for_each_netdev_feature' + - 'for_each_netdev_in_bond_rcu' + - 'for_each_netdev_rcu' + - 'for_each_netdev_reverse' + - 'for_each_netdev_safe' + - 'for_each_net_rcu' + - 'for_each_new_connector_in_state' + - 'for_each_new_crtc_in_state' + - 'for_each_new_mst_mgr_in_state' + - 'for_each_new_plane_in_state' + - 'for_each_new_private_obj_in_state' + - 'for_each_node' + - 'for_each_node_by_name' + - 'for_each_node_by_type' + - 'for_each_node_mask' + - 'for_each_node_state' + - 'for_each_node_with_cpus' + - 'for_each_node_with_property' + - 'for_each_nonreserved_multicast_dest_pgid' + - 'for_each_of_allnodes' + - 'for_each_of_allnodes_from' + - 'for_each_of_cpu_node' + - 'for_each_of_pci_range' + - 'for_each_old_connector_in_state' + - 'for_each_old_crtc_in_state' + - 'for_each_old_mst_mgr_in_state' + - 'for_each_oldnew_connector_in_state' + - 'for_each_oldnew_crtc_in_state' + - 'for_each_oldnew_mst_mgr_in_state' + - 'for_each_oldnew_plane_in_state' + - 'for_each_oldnew_plane_in_state_reverse' + - 'for_each_oldnew_private_obj_in_state' + - 'for_each_old_plane_in_state' + - 'for_each_old_private_obj_in_state' + - 'for_each_online_cpu' + - 'for_each_online_node' + - 'for_each_online_pgdat' + - 'for_each_pci_bridge' + - 'for_each_pci_dev' + - 'for_each_pci_msi_entry' + - 'for_each_pcm_streams' + - 'for_each_physmem_range' + - 'for_each_populated_zone' + - 'for_each_possible_cpu' + - 'for_each_present_cpu' + - 'for_each_prime_number' + - 'for_each_prime_number_from' + - 'for_each_process' + - 'for_each_process_thread' + - 'for_each_prop_codec_conf' + - 'for_each_prop_dai_codec' + - 'for_each_prop_dai_cpu' + - 'for_each_prop_dlc_codecs' + - 'for_each_prop_dlc_cpus' + - 'for_each_prop_dlc_platforms' + - 'for_each_property_of_node' + - 'for_each_registered_fb' + - 'for_each_requested_gpio' + - 'for_each_requested_gpio_in_range' + - 'for_each_reserved_mem_range' + - 'for_each_reserved_mem_region' + - 'for_each_rtd_codec_dais' + - 'for_each_rtd_components' + - 'for_each_rtd_cpu_dais' + - 'for_each_rtd_dais' + - 'for_each_set_bit' + - 'for_each_set_bit_from' + - 'for_each_set_clump8' + - 'for_each_sg' + - 'for_each_sg_dma_page' + - 'for_each_sg_page' + - 'for_each_sgtable_dma_page' + - 'for_each_sgtable_dma_sg' + - 'for_each_sgtable_page' + - 'for_each_sgtable_sg' + - 'for_each_sibling_event' + - 'for_each_subelement' + - 'for_each_subelement_extid' + - 'for_each_subelement_id' + - '__for_each_thread' + - 'for_each_thread' + - 'for_each_unicast_dest_pgid' + - 'for_each_vsi' + - 'for_each_wakeup_source' + - 'for_each_zone' + - 'for_each_zone_zonelist' + - 'for_each_zone_zonelist_nodemask' + - 'fwnode_for_each_available_child_node' + - 'fwnode_for_each_child_node' + - 'fwnode_graph_for_each_endpoint' + - 'gadget_for_each_ep' + - 'genradix_for_each' + - 'genradix_for_each_from' + - 'hash_for_each' + - 'hash_for_each_possible' + - 'hash_for_each_possible_rcu' + - 'hash_for_each_possible_rcu_notrace' + - 'hash_for_each_possible_safe' + - 'hash_for_each_rcu' + - 'hash_for_each_safe' + - 'hctx_for_each_ctx' + - 'hlist_bl_for_each_entry' + - 'hlist_bl_for_each_entry_rcu' + - 'hlist_bl_for_each_entry_safe' + - 'hlist_for_each' + - 'hlist_for_each_entry' + - 'hlist_for_each_entry_continue' + - 'hlist_for_each_entry_continue_rcu' + - 'hlist_for_each_entry_continue_rcu_bh' + - 'hlist_for_each_entry_from' + - 'hlist_for_each_entry_from_rcu' + - 'hlist_for_each_entry_rcu' + - 'hlist_for_each_entry_rcu_bh' + - 'hlist_for_each_entry_rcu_notrace' + - 'hlist_for_each_entry_safe' + - 'hlist_for_each_entry_srcu' + - '__hlist_for_each_rcu' + - 'hlist_for_each_safe' + - 'hlist_nulls_for_each_entry' + - 'hlist_nulls_for_each_entry_from' + - 'hlist_nulls_for_each_entry_rcu' + - 'hlist_nulls_for_each_entry_safe' + - 'i3c_bus_for_each_i2cdev' + - 'i3c_bus_for_each_i3cdev' + - 'ide_host_for_each_port' + - 'ide_port_for_each_dev' + - 'ide_port_for_each_present_dev' + - 'idr_for_each_entry' + - 'idr_for_each_entry_continue' + - 'idr_for_each_entry_continue_ul' + - 'idr_for_each_entry_ul' + - 'in_dev_for_each_ifa_rcu' + - 'in_dev_for_each_ifa_rtnl' + - 'inet_bind_bucket_for_each' + - 'inet_lhash2_for_each_icsk_rcu' + - 'key_for_each' + - 'key_for_each_safe' + - 'klp_for_each_func' + - 'klp_for_each_func_safe' + - 'klp_for_each_func_static' + - 'klp_for_each_object' + - 'klp_for_each_object_safe' + - 'klp_for_each_object_static' + - 'kunit_suite_for_each_test_case' + - 'kvm_for_each_memslot' + - 'kvm_for_each_vcpu' + - 'list_for_each' + - 'list_for_each_codec' + - 'list_for_each_codec_safe' + - 'list_for_each_continue' + - 'list_for_each_entry' + - 'list_for_each_entry_continue' + - 'list_for_each_entry_continue_rcu' + - 'list_for_each_entry_continue_reverse' + - 'list_for_each_entry_from' + - 'list_for_each_entry_from_rcu' + - 'list_for_each_entry_from_reverse' + - 'list_for_each_entry_lockless' + - 'list_for_each_entry_rcu' + - 'list_for_each_entry_reverse' + - 'list_for_each_entry_safe' + - 'list_for_each_entry_safe_continue' + - 'list_for_each_entry_safe_from' + - 'list_for_each_entry_safe_reverse' + - 'list_for_each_entry_srcu' + - 'list_for_each_prev' + - 'list_for_each_prev_safe' + - 'list_for_each_safe' + - 'llist_for_each' + - 'llist_for_each_entry' + - 'llist_for_each_entry_safe' + - 'llist_for_each_safe' + - 'mci_for_each_dimm' + - 'media_device_for_each_entity' + - 'media_device_for_each_intf' + - 'media_device_for_each_link' + - 'media_device_for_each_pad' + - 'nanddev_io_for_each_page' + - 'netdev_for_each_lower_dev' + - 'netdev_for_each_lower_private' + - 'netdev_for_each_lower_private_rcu' + - 'netdev_for_each_mc_addr' + - 'netdev_for_each_uc_addr' + - 'netdev_for_each_upper_dev_rcu' + - 'netdev_hw_addr_list_for_each' + - 'nft_rule_for_each_expr' + - 'nla_for_each_attr' + - 'nla_for_each_nested' + - 'nlmsg_for_each_attr' + - 'nlmsg_for_each_msg' + - 'nr_neigh_for_each' + - 'nr_neigh_for_each_safe' + - 'nr_node_for_each' + - 'nr_node_for_each_safe' + - 'of_for_each_phandle' + - 'of_property_for_each_string' + - 'of_property_for_each_u32' + - 'pci_bus_for_each_resource' + - 'pcl_for_each_chunk' + - 'pcl_for_each_segment' + - 'pcm_for_each_format' + - 'ping_portaddr_for_each_entry' + - 'plist_for_each' + - 'plist_for_each_continue' + - 'plist_for_each_entry' + - 'plist_for_each_entry_continue' + - 'plist_for_each_entry_safe' + - 'plist_for_each_safe' + - 'pnp_for_each_card' + - 'pnp_for_each_dev' + - 'protocol_for_each_card' + - 'protocol_for_each_dev' + - 'queue_for_each_hw_ctx' + - 'radix_tree_for_each_slot' + - 'radix_tree_for_each_tagged' + - 'rb_for_each' + - 'rbtree_postorder_for_each_entry_safe' + - 'rdma_for_each_block' + - 'rdma_for_each_port' + - 'rdma_umem_for_each_dma_block' + - 'resource_list_for_each_entry' + - 'resource_list_for_each_entry_safe' + - 'rhl_for_each_entry_rcu' + - 'rhl_for_each_rcu' + - 'rht_for_each' + - 'rht_for_each_entry' + - 'rht_for_each_entry_from' + - 'rht_for_each_entry_rcu' + - 'rht_for_each_entry_rcu_from' + - 'rht_for_each_entry_safe' + - 'rht_for_each_from' + - 'rht_for_each_rcu' + - 'rht_for_each_rcu_from' + - '__rq_for_each_bio' + - 'rq_for_each_bvec' + - 'rq_for_each_segment' + - 'scsi_for_each_prot_sg' + - 'scsi_for_each_sg' + - 'sctp_for_each_hentry' + - 'sctp_skb_for_each' + - 'shdma_for_each_chan' + - '__shost_for_each_device' + - 'shost_for_each_device' + - 'sk_for_each' + - 'sk_for_each_bound' + - 'sk_for_each_entry_offset_rcu' + - 'sk_for_each_from' + - 'sk_for_each_rcu' + - 'sk_for_each_safe' + - 'sk_nulls_for_each' + - 'sk_nulls_for_each_from' + - 'sk_nulls_for_each_rcu' + - 'snd_array_for_each' + - 'snd_pcm_group_for_each_entry' + - 'snd_soc_dapm_widget_for_each_path' + - 'snd_soc_dapm_widget_for_each_path_safe' + - 'snd_soc_dapm_widget_for_each_sink_path' + - 'snd_soc_dapm_widget_for_each_source_path' + - 'tb_property_for_each' + - 'tcf_exts_for_each_action' + - 'udp_portaddr_for_each_entry' + - 'udp_portaddr_for_each_entry_rcu' + - 'usb_hub_for_each_child' + - 'v4l2_device_for_each_subdev' + - 'v4l2_m2m_for_each_dst_buf' + - 'v4l2_m2m_for_each_dst_buf_safe' + - 'v4l2_m2m_for_each_src_buf' + - 'v4l2_m2m_for_each_src_buf_safe' + - 'virtio_device_for_each_vq' + - 'while_for_each_ftrace_op' + - 'xa_for_each' + - 'xa_for_each_marked' + - 'xa_for_each_range' + - 'xa_for_each_start' + - 'xas_for_each' + - 'xas_for_each_conflict' + - 'xas_for_each_marked' + - 'xbc_array_for_each_value' + - 'xbc_for_each_key_value' + - 'xbc_node_for_each_array_value' + - 'xbc_node_for_each_child' + - 'xbc_node_for_each_key_value' + - 'zorro_for_each_dev' + +#IncludeBlocks: Preserve # Unknown to clang-format-5.0 +IncludeCategories: + - Regex: '.*' + Priority: 1 +IncludeIsMainRegex: '(Test)?$' +IndentCaseLabels: false +#IndentPPDirectives: None # Unknown to clang-format-5.0 +IndentWidth: 8 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +#ObjCBinPackProtocolList: Auto # Unknown to clang-format-5.0 +ObjCBlockIndentWidth: 8 +ObjCSpaceAfterProperty: true +ObjCSpaceBeforeProtocolList: true + +# Taken from git's rules +#PenaltyBreakAssignment: 10 # Unknown to clang-format-4.0 +PenaltyBreakBeforeFirstCallParameter: 30 +PenaltyBreakComment: 10 +PenaltyBreakFirstLessLess: 0 +PenaltyBreakString: 10 +PenaltyExcessCharacter: 100 +PenaltyReturnTypeOnItsOwnLine: 60 + +PointerAlignment: Right +ReflowComments: false +SortIncludes: false +#SortUsingDeclarations: false # Unknown to clang-format-4.0 +SpaceAfterCStyleCast: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +#SpaceBeforeCtorInitializerColon: true # Unknown to clang-format-5.0 +#SpaceBeforeInheritanceColon: true # Unknown to clang-format-5.0 +SpaceBeforeParens: ControlStatements +#SpaceBeforeRangeBasedForLoopColon: true # Unknown to clang-format-5.0 +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInContainerLiterals: false +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Latest +TabWidth: 8 +UseTab: AlignWithSpaces +... @@ -19,7 +19,7 @@ CROSS_COMPILE ?= $(ARCH)-unknown-elf OBJCOPY != [ $(LLVM) ] \ && echo llvm-objcopy \ - || echo $(CROSS_COMPILE)-objcopy + || echo $(CROSS_COMPILE)-objcopy COMPILER != [ $(LLVM) ] \ && echo clang --target="$(CROSS_COMPILE)" \ @@ -82,6 +82,10 @@ kernel.bin: kernel.elf apos.bin: init.bin kernel.bin cat init.bin kernel.bin > apos.bin +format: + find arch lib common include -iname '*.[ch]' \ + -exec clang-format -i -style=file {} \; + clean: $(RM) -r $(CLEANUP) diff --git a/arch/riscv64/config.h b/arch/riscv64/config.h index 0ef22fa..707c0b9 100644 --- a/arch/riscv64/config.h +++ b/arch/riscv64/config.h @@ -2,33 +2,33 @@ /* --- START ARCH USER CONFIG VALUES --- */ /* physical address to which the kernel will be loaded */ -#define RAM_BASE 0x80000000 -#define PM_KERN_BASE (RAM_BASE + SZ_512K) -#define PM_KERN_SIZE (SZ_256K) -#define PM_KERN_TOP (PM_KERN_BASE + PM_KERN_SIZE) +#define RAM_BASE 0x80000000 +#define PM_KERN_BASE (RAM_BASE + SZ_512K) +#define PM_KERN_SIZE (SZ_256K) +#define PM_KERN_TOP (PM_KERN_BASE + PM_KERN_SIZE) /* --- END ARCH USER CONFIG VALUES --- */ /* don't touch >:( */ -#define PM_STACK_BASE (PM_KERN_BASE + SZ_256K) -#define PM_STACK_SIZE (SZ_256K) -#define PM_STACK_TOP (PM_STACK_BASE + PM_STACK_SIZE) +#define PM_STACK_BASE (PM_KERN_BASE + SZ_256K) +#define PM_STACK_SIZE (SZ_256K) +#define PM_STACK_TOP (PM_STACK_BASE + PM_STACK_SIZE) -#define VM_DMAP (0xffffffc000000000) /* testing for now */ -#define VM_KERN (VM_DMAP + SZ_256K) -#define TMP_PTE (-SZ_2G) -#define ROOT_PTE (0) -#define ROOT_REGION (SZ_4K) +#define VM_DMAP (0xffffffc000000000) /* testing for now */ +#define VM_KERN (VM_DMAP + SZ_256K) +#define TMP_PTE (-SZ_2G) +#define ROOT_PTE (0) +#define ROOT_REGION (SZ_4K) -#define IO_PAGE 511 -#define KSTART_PAGE 256 -#define CSTACK_PAGE 255 +#define IO_PAGE 511 +#define KSTART_PAGE 256 +#define CSTACK_PAGE 255 /* assume Sv39, probably wouldn't be too difficult to use runtime parameters * instead. First 4K is reserved for NULL, but I suppose it could be mapped * later if *absolutely* necessary. */ -#define UVMEM_START (SZ_4K) -#define UVMEM_END (SZ_256G - SZ_1G) +#define UVMEM_START (SZ_4K) +#define UVMEM_END (SZ_256G - SZ_1G) -#define PROC_STACK_TOP (SZ_256G) +#define PROC_STACK_TOP (SZ_256G) #define PROC_STACK_BASE (SZ_256G - SZ_1G) diff --git a/arch/riscv64/include/csr.h b/arch/riscv64/include/csr.h index 43c365b..7f9fc1f 100644 --- a/arch/riscv64/include/csr.h +++ b/arch/riscv64/include/csr.h @@ -3,43 +3,42 @@ #include <apos/utils.h> -#define SATP_MODE_Sv32 0x80000000 -#define SATP_MODE_Sv39 0x8000000000000000 -#define SATP_MODE_Sv48 0x9000000000000000 - +#define SATP_MODE_Sv32 0x80000000 +#define SATP_MODE_Sv39 0x8000000000000000 +#define SATP_MODE_Sv48 0x9000000000000000 /* supervisor CSR registers */ -#define CSR_SSTATUS 0x100 -#define CSR_SIE 0x104 -#define CSR_STVEC 0x105 -#define CSR_SCOUNTEREN 0x106 +#define CSR_SSTATUS 0x100 +#define CSR_SIE 0x104 +#define CSR_STVEC 0x105 +#define CSR_SCOUNTEREN 0x106 -#define CSR_SENVCFG 0x10A +#define CSR_SENVCFG 0x10A -#define CSR_SSCRATCH 0x140 -#define CSR_SEPC 0x141 -#define CSR_SCAUSE 0x142 -#define CSR_STVAL 0x143 -#define CSR_SIP 0x144 +#define CSR_SSCRATCH 0x140 +#define CSR_SEPC 0x141 +#define CSR_SCAUSE 0x142 +#define CSR_STVAL 0x143 +#define CSR_SIP 0x144 -#define CSR_SATP 0x180 +#define CSR_SATP 0x180 -#define CSR_SCONTEXT 0x5A8 +#define CSR_SCONTEXT 0x5A8 /* Exception causes */ -#define EXC_INST_MISALIGNED 0 -#define EXC_INST_ACCESS 1 -#define EXC_BREAKPOINT 3 -#define EXC_LOAD_ACCESS 5 -#define EXC_STORE_ACCESS 7 -#define EXC_SYSCALL 8 -#define EXC_INST_PAGE_FAULT 12 -#define EXC_LOAD_PAGE_FAULT 13 -#define EXC_STORE_PAGE_FAULT 15 +#define EXC_INST_MISALIGNED 0 +#define EXC_INST_ACCESS 1 +#define EXC_BREAKPOINT 3 +#define EXC_LOAD_ACCESS 5 +#define EXC_STORE_ACCESS 7 +#define EXC_SYSCALL 8 +#define EXC_INST_PAGE_FAULT 12 +#define EXC_LOAD_PAGE_FAULT 13 +#define EXC_STORE_PAGE_FAULT 15 /* status CSR bits */ -#define SSTATUS_SUM (1 << 18) -#define SSTATUS_SPP (1 << 8) +#define SSTATUS_SUM (1 << 18) +#define SSTATUS_SPP (1 << 8) /* directly lifted from Linux:/arch/riscv/include/asm/asm.h:9-13 */ #if defined(__ASSEMBLY__) @@ -48,16 +47,16 @@ #define __ASM_STR(x) #x #endif -#define csr_read(csr, res)\ - __asm__ volatile ("csrr %0, " __ASM_STR(csr) : "=r" (res) : : "memory") +#define csr_read(csr, res) \ + __asm__ volatile("csrr %0, " __ASM_STR(csr) : "=r"(res) : : "memory") -#define csr_write(csr, val)\ - __asm__ volatile ("csrw " __ASM_STR(csr) ", %0" : : "r" (val) : "memory") +#define csr_write(csr, val) \ + __asm__ volatile("csrw " __ASM_STR(csr) ", %0" : : "r"(val) : "memory") -#define csr_set(csr, val)\ - __asm__ volatile ("csrs " __ASM_STR(csr) ", %0" : : "r" (val) : "memory") +#define csr_set(csr, val) \ + __asm__ volatile("csrs " __ASM_STR(csr) ", %0" : : "r"(val) : "memory") -#define csr_clear(csr, val)\ - __asm__ volatile ("csrc " __ASM_STR(csr) ", %0" : : "r" (val) : "memory") +#define csr_clear(csr, val) \ + __asm__ volatile("csrc " __ASM_STR(csr) ", %0" : : "r"(val) : "memory") #endif /* APOS_CSR_H */ diff --git a/arch/riscv64/include/pages.h b/arch/riscv64/include/pages.h index 643d3b4..20dab3d 100644 --- a/arch/riscv64/include/pages.h +++ b/arch/riscv64/include/pages.h @@ -1,10 +1,10 @@ #ifndef APOS_RISCV_PAGES_H #define APOS_RISCV_PAGES_H -#define MM_KPAGE MM_O0 -#define MM_MPAGE MM_O1 -#define MM_GPAGE MM_O2 -#define MM_TPAGE MM_O3 +#define MM_KPAGE MM_O0 +#define MM_MPAGE MM_O1 +#define MM_GPAGE MM_O2 +#define MM_TPAGE MM_O3 #define MM_KPAGE_SIZE SZ_4K #define MM_MPAGE_SIZE SZ_2M diff --git a/arch/riscv64/include/sbi.h b/arch/riscv64/include/sbi.h index 609849d..e6ceb92 100644 --- a/arch/riscv64/include/sbi.h +++ b/arch/riscv64/include/sbi.h @@ -5,8 +5,9 @@ struct sbiret { long value; }; -struct sbiret sbi_ecall(int ext, int fid, - unsigned long arg0, unsigned long arg1, unsigned long arg2, - unsigned long arg3, unsigned long arg4, unsigned long arg5); +struct sbiret sbi_ecall(int ext, int fid, unsigned long arg0, + unsigned long arg1, unsigned long arg2, + unsigned long arg3, unsigned long arg4, + unsigned long arg5); #endif /* APOS_RISCV_SBI_H */ diff --git a/arch/riscv64/init/init.c b/arch/riscv64/init/init.c index 94f9777..f844dbb 100644 --- a/arch/riscv64/init/init.c +++ b/arch/riscv64/init/init.c @@ -20,16 +20,18 @@ void init_bootmem() size_t flags = VM_V | VM_X | VM_R | VM_W; extern char *__init_start; - root_branch = (struct init_vmem *)align_down((size_t)&__init_start - SZ_4K, SZ_4K); + root_branch = (struct init_vmem *)align_down( + (size_t)&__init_start - SZ_4K, SZ_4K); /* direct mapping (temp) */ - for(size_t i = 0; i < CSTACK_PAGE; ++i) - root_branch->leaf[i] = (int*)to_pte(SZ_1G * i, flags); + for (size_t i = 0; i < CSTACK_PAGE; ++i) + root_branch->leaf[i] = (int *)to_pte(SZ_1G * i, flags); /* kernel (also sort of direct mapping) */ flags |= VM_G; - for(size_t i = KSTART_PAGE; i < IO_PAGE; ++i) - root_branch->leaf[i] = (int *)to_pte(RAM_BASE + SZ_1G * (i - 256), flags); + for (size_t i = KSTART_PAGE; i < IO_PAGE; ++i) + root_branch->leaf[i] = + (int *)to_pte(RAM_BASE + SZ_1G * (i - 256), flags); /* kernel IO, map to 0 for now, will be updated in the future */ root_branch->leaf[IO_PAGE] = (int *)to_pte(0, flags); @@ -45,17 +47,17 @@ void move_kernel() size_t sz = (size_t)&__kernel_size; char *src = (char *)&__init_end; char *dst = (char *)VM_KERN; - for(size_t i = 0; i < sz; ++i) + for (size_t i = 0; i < sz; ++i) dst[i] = src[i]; } -#define __va_reg(reg)\ -{\ - vm_t reg = 0;\ - __asm__("mv %0, " QUOTE(reg) : "=r" (reg) :: );\ - reg = (vm_t)__va(reg);\ - __asm__("mv " QUOTE(reg) ", %0" :: "rK" (reg) : );\ -} +#define __va_reg(reg) \ + { \ + vm_t reg = 0; \ + __asm__("mv %0, " QUOTE(reg) : "=r"(reg)::); \ + reg = (vm_t)__va(reg); \ + __asm__("mv " QUOTE(reg) ", %0" ::"rK"(reg) :); \ + } void init(void *fdt) { diff --git a/arch/riscv64/kernel/irq.c b/arch/riscv64/kernel/irq.c index a88288f..27e0bd0 100644 --- a/arch/riscv64/kernel/irq.c +++ b/arch/riscv64/kernel/irq.c @@ -7,7 +7,7 @@ void init_irq(void *fdt) { UNUSED(fdt); csr_write(CSR_STVEC, &handle_irq); - + long s = 0; csr_read(CSR_SIE, s); info("CSR_SIE: %lx\n", s); @@ -15,7 +15,8 @@ void init_irq(void *fdt) __aligned(4) void handle_irq() { - while(1); + while (1) + ; } /* very simple for now */ diff --git a/arch/riscv64/kernel/pmem.c b/arch/riscv64/kernel/pmem.c index 404329c..fc3fa40 100644 --- a/arch/riscv64/kernel/pmem.c +++ b/arch/riscv64/kernel/pmem.c @@ -1,6 +1,7 @@ #include <arch/pmem.h> -stat_t stat_pmem_conf(void *fdt, size_t *max_order, size_t *base_bits, size_t bits[NUM_ORDERS]) +stat_t stat_pmem_conf(void *fdt, size_t *max_order, size_t *base_bits, + size_t bits[NUM_ORDERS]) { UNUSED(fdt); @@ -8,7 +9,7 @@ stat_t stat_pmem_conf(void *fdt, size_t *max_order, size_t *base_bits, size_t bi *max_order = 2; *base_bits = 12; /* we can assume bits[] is zeroed out beforehand */ - for(size_t i = 0; i <= *max_order; ++i) + for (size_t i = 0; i <= *max_order; ++i) bits[i] = 9; return OK; diff --git a/arch/riscv64/kernel/proc.c b/arch/riscv64/kernel/proc.c index e2cbcea..ef8f24e 100644 --- a/arch/riscv64/kernel/proc.c +++ b/arch/riscv64/kernel/proc.c @@ -5,8 +5,8 @@ stat_t jump_to_userspace(struct tcb *t, int argc, char **argv) { csr_write(CSR_SEPC, t->entry); - __asm__ volatile ("mv sp, %0\n" : "=r" (t->proc_stack) :: "memory"); - __asm__ volatile ("sret\n" ::: "memory"); + __asm__ volatile("mv sp, %0\n" : "=r"(t->proc_stack)::"memory"); + __asm__ volatile("sret\n" ::: "memory"); /* we should never reach this */ return ERR_ADDR; } diff --git a/arch/riscv64/kernel/vmem.c b/arch/riscv64/kernel/vmem.c index cd822ae..46ddf29 100644 --- a/arch/riscv64/kernel/vmem.c +++ b/arch/riscv64/kernel/vmem.c @@ -7,30 +7,30 @@ #include <pages.h> #include <csr.h> -#define pte_ppn(pte) (((pm_t)(pte)) >> 10) -#define pte_flags(pte) (((pm_t)(pte)) & 0xff) -#define to_pte(p, f) ((pm_to_pnum(p) << 10) | (f)) -#define pte_addr(pte) __va(pnum_to_paddr(pte_ppn(pte))) -#define pte_paddr(pte) (pnum_to_paddr(pte_ppn(pte))) +#define pte_ppn(pte) (((pm_t)(pte)) >> 10) +#define pte_flags(pte) (((pm_t)(pte)) & 0xff) +#define to_pte(p, f) ((pm_to_pnum(p) << 10) | (f)) +#define pte_addr(pte) __va(pnum_to_paddr(pte_ppn(pte))) +#define pte_paddr(pte) (pnum_to_paddr(pte_ppn(pte))) #define vm_to_index(a, o) (pm_to_index(a, o)) -#define is_active(pte) (pte_flags(pte) & VM_V) -#define is_leaf(pte) (is_active(pte) && (pte_flags(pte) & ~VM_V)) -#define is_branch(pte) (is_active(pte) && !(pte_flags(pte) & ~VM_V)) +#define is_active(pte) (pte_flags(pte) & VM_V) +#define is_leaf(pte) (is_active(pte) && (pte_flags(pte) & ~VM_V)) +#define is_branch(pte) (is_active(pte) && !(pte_flags(pte) & ~VM_V)) static pm_t *__find_vmem(struct vm_branch *b, vm_t v, enum mm_order *o) { enum mm_order top = __mm_max_order; - if(o) + if (o) *o = MM_O0; do { size_t idx = vm_to_index(v, top); pm_t pte = (pm_t)b->leaf[idx]; - if(!pte) + if (!pte) return 0; - if(is_leaf(pte)){ - if(o) + if (is_leaf(pte)) { + if (o) *o = top; return (pm_t *)&b->leaf[idx]; @@ -42,10 +42,11 @@ static pm_t *__find_vmem(struct vm_branch *b, vm_t v, enum mm_order *o) return 0; } -stat_t mod_vpage(struct vm_branch *branch, vm_t vaddr, pm_t paddr, vmflags_t flags) +stat_t mod_vpage(struct vm_branch *branch, vm_t vaddr, pm_t paddr, + vmflags_t flags) { pm_t *pte = __find_vmem(branch, vaddr, 0); - if(pte){ + if (pte) { *pte = to_pte((pm_t)__pa(paddr), vp_flags(flags)); return OK; } @@ -56,14 +57,14 @@ stat_t mod_vpage(struct vm_branch *branch, vm_t vaddr, pm_t paddr, vmflags_t fla /* huh, should probably add status flags etc. to all my API functions. Damn, I'm * lazy. */ stat_t stat_vpage(struct vm_branch *branch, vm_t vaddr, pm_t *paddr, - enum mm_order *order, vmflags_t *flags) + enum mm_order *order, vmflags_t *flags) { pm_t *pte = __find_vmem(branch, vaddr, order); - if(pte){ - if(paddr) + if (pte) { + if (paddr) *paddr = (pm_t)pte_addr(*pte); - if(flags) + if (flags) *flags = pte_flags(*pte); return OK; @@ -81,19 +82,20 @@ static struct vm_branch *__create_leaf() static void __destroy_branch(struct vm_branch *b) { - if(!b) + if (!b) return; - for(size_t i = 0; i < BASE_PAGE_SIZE / sizeof(pm_t); ++i){ - if(is_branch(b->leaf[i])) - __destroy_branch((struct vm_branch *)pte_addr(b->leaf[i])); + for (size_t i = 0; i < BASE_PAGE_SIZE / sizeof(pm_t); ++i) { + if (is_branch(b->leaf[i])) + __destroy_branch( + (struct vm_branch *)pte_addr(b->leaf[i])); free_page(MM_KPAGE, (pm_t)pte_addr(b->leaf[i])); } } -stat_t map_vpage(struct vm_branch *branch, - pm_t paddr, vm_t vaddr, vmflags_t flags, enum mm_order order) +stat_t map_vpage(struct vm_branch *branch, pm_t paddr, vm_t vaddr, + vmflags_t flags, enum mm_order order) { enum mm_order top = __mm_max_order; while (top != order) { @@ -102,24 +104,24 @@ stat_t map_vpage(struct vm_branch *branch, if (!branch->leaf[idx]) branch->leaf[idx] = __create_leaf(); - branch = (struct vm_branch *)pte_addr(branch->leaf[idx]); top--; } size_t idx = vm_to_index(vaddr, top); - if (is_branch(branch->leaf[idx])) /* something has gone terribly wrong? */ + if (is_branch( + branch->leaf[idx])) /* something has gone terribly wrong? */ __destroy_branch(branch->leaf[idx]); - branch->leaf[idx] = (struct vm_branch *)to_pte((pm_t)__pa(paddr), vp_flags(flags)); + branch->leaf[idx] = + (struct vm_branch *)to_pte((pm_t)__pa(paddr), vp_flags(flags)); return OK; } stat_t unmap_vpage(struct vm_branch *branch, vm_t vaddr) { - pm_t *pte = __find_vmem(branch, vaddr, 0); - if(pte){ + if (pte) { *pte = 0; return OK; } @@ -129,24 +131,27 @@ stat_t unmap_vpage(struct vm_branch *branch, vm_t vaddr) void flush_tlb() { - __asm__ volatile ("sfence.vma %0\n" :: "r" (cpu_id()) : "memory"); + __asm__ volatile("sfence.vma %0\n" ::"r"(cpu_id()) : "memory"); } void flush_tlb_all() { - __asm__ volatile ("sfence.vma\n" ::: "memory"); + __asm__ volatile("sfence.vma\n" ::: "memory"); } static void __start_vmem(struct vm_branch *branch, enum mm_mode m) { branch = (struct vm_branch *)__pa(branch); - if(m == Sv32) - csr_write(CSR_SATP, SATP_MODE_Sv32 | pm_to_pnum((pm_t)(branch))); + if (m == Sv32) + csr_write(CSR_SATP, + SATP_MODE_Sv32 | pm_to_pnum((pm_t)(branch))); else if (m == Sv39) - csr_write(CSR_SATP, SATP_MODE_Sv39 | pm_to_pnum((pm_t)(branch))); + csr_write(CSR_SATP, + SATP_MODE_Sv39 | pm_to_pnum((pm_t)(branch))); else - csr_write(CSR_SATP, SATP_MODE_Sv48 | pm_to_pnum((pm_t)(branch))); + csr_write(CSR_SATP, + SATP_MODE_Sv48 | pm_to_pnum((pm_t)(branch))); flush_tlb_all(); /* Sv57 && Sv64 in the future? */ @@ -167,8 +172,9 @@ struct vm_branch *init_vmem(void *fdt) void populate_root_branch(struct vm_branch *b) { size_t flags = VM_V | VM_R | VM_W | VM_X | VM_G; - for(size_t i = KSTART_PAGE; i < IO_PAGE; ++i) - b->leaf[i] = (struct vm_branch *)to_pte(RAM_BASE + SZ_1G * (i - KSTART_PAGE), flags); + for (size_t i = KSTART_PAGE; i < IO_PAGE; ++i) + b->leaf[i] = (struct vm_branch *)to_pte( + RAM_BASE + SZ_1G * (i - KSTART_PAGE), flags); /* map kernel IO to zero for now, this will be overridden later * (if at all) */ @@ -180,7 +186,8 @@ vm_t setup_kernel_io(struct vm_branch *b, vm_t paddr) { /* assume Sv39 for now */ pm_t gigapage = paddr / MM_GPAGE_SIZE; - b->leaf[IO_PAGE] = (struct vm_branch *)to_pte(gigapage, VM_V | VM_R | VM_W); + b->leaf[IO_PAGE] = + (struct vm_branch *)to_pte(gigapage, VM_V | VM_R | VM_W); return -SZ_1G + paddr - (gigapage * MM_GPAGE_SIZE); } #endif diff --git a/common/bits.c b/common/bits.c index b9814f6..698c082 100644 --- a/common/bits.c +++ b/common/bits.c @@ -12,21 +12,19 @@ __weak uint16_t __bswap16(const uint16_t u) #undef __bswap32 __weak uint32_t __bswap32(const uint32_t u) { - return (u & 0xff000000) >> 24 | - (u & 0x00ff0000) >> 8 | - (u & 0x0000ff00) << 8 | - (u & 0x000000ff) << 24; + return (u & 0xff000000) >> 24 | (u & 0x00ff0000) >> 8 | + (u & 0x0000ff00) << 8 | (u & 0x000000ff) << 24; } #undef __bswap64 __weak uint64_t __bswap64(const uint64_t u) { - return (u & 0xff00000000000000ULL) >> 56 | - (u & 0x00ff000000000000ULL) >> 40 | - (u & 0x0000ff0000000000ULL) >> 24 | - (u & 0x000000ff00000000ULL) >> 8 | - (u & 0x00000000ff000000ULL) << 8 | - (u & 0x0000000000ff0000ULL) << 24 | - (u & 0x000000000000ff00ULL) << 40 | - (u & 0x00000000000000ffULL) << 56; + return (u & 0xff00000000000000ULL) >> 56 | + (u & 0x00ff000000000000ULL) >> 40 | + (u & 0x0000ff0000000000ULL) >> 24 | + (u & 0x000000ff00000000ULL) >> 8 | + (u & 0x00000000ff000000ULL) << 8 | + (u & 0x0000000000ff0000ULL) << 24 | + (u & 0x000000000000ff00ULL) << 40 | + (u & 0x00000000000000ffULL) << 56; } diff --git a/common/debug.c b/common/debug.c index 330a3ed..43c9ae5 100644 --- a/common/debug.c +++ b/common/debug.c @@ -11,7 +11,7 @@ static struct dbg_info { pm_t dbg_ptr; enum serial_dev dev; -} dbg_info = (struct dbg_info){0}; +} dbg_info = (struct dbg_info){ 0 }; void init_dbg(const void *fdt) { @@ -75,7 +75,8 @@ static void __putchar(char c) if (!port) return; - while(__serial_tx_empty() == 0); + while (__serial_tx_empty() == 0) + ; port->data = c; } @@ -91,13 +92,14 @@ static enum serial_dev __serial_dev_enum(const char *dev_name) struct dbg_info dbg_from_fdt(const void *fdt) { int chosen_offset = fdt_path_offset(fdt, "/chosen"); - const char *stdout = fdt_getprop(fdt, chosen_offset, "stdout-path", NULL); + const char *stdout = + fdt_getprop(fdt, chosen_offset, "stdout-path", NULL); int stdout_offset = fdt_path_offset(fdt, stdout); /* get serial device type */ const char *dev_name = (const char *)fdt_getprop(fdt, stdout_offset, - "compatible", NULL); + "compatible", NULL); enum serial_dev dev = __serial_dev_enum(dev_name); @@ -107,38 +109,38 @@ struct dbg_info dbg_from_fdt(const void *fdt) pm_t dbg_ptr = (pm_t)fdt_load_int_ptr(ci.addr_cells, reg_ptr); - return (struct dbg_info){dbg_ptr, dev}; + return (struct dbg_info){ dbg_ptr, dev }; } void setup_dbg(vm_t pt, enum serial_dev dev) { switch (dev) { - case NS16550A: - port = (struct ns16550a *)pt; - break; + case NS16550A: + port = (struct ns16550a *)pt; + break; } /* in the future possibly configure the serial connection, though the * defaults (set by U-boot) seem to work alright */ } -#define LEFT_FLAG (1 << 0) -#define SIGN_FLAG (1 << 1) -#define HASH_FLAG (1 << 2) -#define ZERO_FLAG (1 << 3) -#define FMT_FLAG (1 << 4) -#define SPACE_FLAG (1 << 5) -#define LONG_FLAG (1 << 6) -#define LLONG_FLAG (1 << 7) -#define SHORT_FLAG (1 << 8) -#define CHAR_FLAG (1 << 9) -#define PRECS_FLAG (1 << 11) +#define LEFT_FLAG (1 << 0) +#define SIGN_FLAG (1 << 1) +#define HASH_FLAG (1 << 2) +#define ZERO_FLAG (1 << 3) +#define FMT_FLAG (1 << 4) +#define SPACE_FLAG (1 << 5) +#define LONG_FLAG (1 << 6) +#define LLONG_FLAG (1 << 7) +#define SHORT_FLAG (1 << 8) +#define CHAR_FLAG (1 << 9) +#define PRECS_FLAG (1 << 11) #define UNSIGN_FLAG (1 << 12) #define WIDTH_FLAG (1 << 13) -#define PAD_FLAG (1 << 14) +#define PAD_FLAG (1 << 14) -#define CONT 1 -#define STOP 0 +#define CONT 1 +#define STOP 0 static bool __is_digit(char c) { @@ -148,38 +150,35 @@ static bool __is_digit(char c) static int __atoi(const char *s) { unsigned int i = 0; - while(__is_digit(*s)){ + while (__is_digit(*s)) { i = i * 10 + (unsigned int)(*(s++) - '0'); } return i; } -static size_t __integral_val(ssize_t value, size_t base, size_t flags, bool print) +static size_t __integral_val(ssize_t value, size_t base, size_t flags, + bool print) { /* assume ascii numbers, which is why 'signed char' is probably fine */ size_t ret = 0; signed char c = 0; -#define handle_type(x)\ - c = (x)value % (x)base;\ +#define handle_type(x) \ + c = (x)value % (x)base; \ value = (x)value / (x)base; - if(!__is_set(flags, UNSIGN_FLAG)){ + if (!__is_set(flags, UNSIGN_FLAG)) { /* signed values, only with i format */ - if(__is_set(flags, LLONG_FLAG)){ + if (__is_set(flags, LLONG_FLAG)) { handle_type(signed long long); - } - else if(__is_set(flags, LONG_FLAG)){ + } else if (__is_set(flags, LONG_FLAG)) { handle_type(signed long); - } - else if(__is_set(flags, SHORT_FLAG)){ + } else if (__is_set(flags, SHORT_FLAG)) { handle_type(signed short); - } - else if(__is_set(flags, CHAR_FLAG)){ + } else if (__is_set(flags, CHAR_FLAG)) { handle_type(signed char); - } - else { + } else { handle_type(signed int); } @@ -188,34 +187,30 @@ static size_t __integral_val(ssize_t value, size_t base, size_t flags, bool prin } else { /* unsigned values, everything else */ - if(__is_set(flags, LLONG_FLAG)){ + if (__is_set(flags, LLONG_FLAG)) { handle_type(unsigned long long); - } - else if(__is_set(flags, LONG_FLAG)){ + } else if (__is_set(flags, LONG_FLAG)) { handle_type(unsigned long); - } - else if(__is_set(flags, SHORT_FLAG)){ + } else if (__is_set(flags, SHORT_FLAG)) { handle_type(unsigned short); - } - else if(__is_set(flags, CHAR_FLAG)){ + } else if (__is_set(flags, CHAR_FLAG)) { handle_type(unsigned char); - } - else { + } else { handle_type(unsigned int); } } #undef handle_type - if(base == 16) + if (base == 16) c += c > 9 ? 'a' - 10 : '0'; else c += '0'; - if(value != 0) + if (value != 0) ret = __integral_val(value, base, flags, print); - if(print) + if (print) __putchar(c); return ret + 1; @@ -232,16 +227,16 @@ static size_t __print_prefix(size_t base) const char *prefix; - if(base == 16) + if (base == 16) prefix = hex; - else if(base == 8) + else if (base == 8) prefix = oct; - else if(base == 2) + else if (base == 2) prefix = bin; else prefix = empty; - for(; *prefix ; ++i) + for (; *prefix; ++i) __putchar(*prefix++); return i; @@ -250,7 +245,7 @@ static size_t __print_prefix(size_t base) static size_t __print_padding(size_t pad, char pad_char) { size_t i = 0; - for(; i < pad; ++i){ + for (; i < pad; ++i) { __putchar(pad_char); } @@ -259,22 +254,21 @@ static size_t __print_padding(size_t pad, char pad_char) static size_t __print_sign(ssize_t value, size_t flags) { - if(__is_set(flags, LLONG_FLAG)) + if (__is_set(flags, LLONG_FLAG)) value = (signed long long)value; - else if(__is_set(flags, LONG_FLAG)) + else if (__is_set(flags, LONG_FLAG)) value = (signed long)value; - else if(__is_set(flags, SHORT_FLAG)) + else if (__is_set(flags, SHORT_FLAG)) value = (signed short)value; - else if(__is_set(flags, CHAR_FLAG)) + else if (__is_set(flags, CHAR_FLAG)) value = (signed char)value; else value = (signed int)value; - if(value < 0){ + if (value < 0) { __putchar('-'); return 1; - } - else if(flags & SIGN_FLAG) { + } else if (flags & SIGN_FLAG) { __putchar('+'); return 1; } @@ -282,10 +276,10 @@ static size_t __print_sign(ssize_t value, size_t flags) return 0; } -static size_t __print_integral(ssize_t value, size_t base, - size_t flags, size_t width) +static size_t __print_integral(ssize_t value, size_t base, size_t flags, + size_t width) { -#define __integral_len(a, b, c) __integral_val((a), (b), (c), false) +#define __integral_len(a, b, c) __integral_val((a), (b), (c), false) #define __integral_print(a, b, c) __integral_val((a), (b), (c), true) size_t ret = 0; @@ -294,30 +288,30 @@ static size_t __print_integral(ssize_t value, size_t base, /* depending on which flags are set, the prefix, sign and right justify has to * be ordereder differently. */ - if(__is_set(flags, ZERO_FLAG)){ - if(!__is_set(flags, UNSIGN_FLAG)) + if (__is_set(flags, ZERO_FLAG)) { + if (!__is_set(flags, UNSIGN_FLAG)) ret += __print_sign(value, flags); - if(__is_set(flags, HASH_FLAG)) + if (__is_set(flags, HASH_FLAG)) ret += __print_prefix(base); - if(pad > 0 && !__is_set(flags, LEFT_FLAG)) + if (pad > 0 && !__is_set(flags, LEFT_FLAG)) ret += __print_padding(pad, '0'); - } else if (__is_set(flags, SPACE_FLAG)){ - if(pad > 0 && !__is_set(flags, LEFT_FLAG)) + } else if (__is_set(flags, SPACE_FLAG)) { + if (pad > 0 && !__is_set(flags, LEFT_FLAG)) ret += __print_padding(pad, ' '); - if(!__is_set(flags, UNSIGN_FLAG)) + if (!__is_set(flags, UNSIGN_FLAG)) ret += __print_sign(value, flags); - if(__is_set(flags, HASH_FLAG)) + if (__is_set(flags, HASH_FLAG)) ret += __print_prefix(base); } else { - if(!__is_set(flags, UNSIGN_FLAG)) + if (!__is_set(flags, UNSIGN_FLAG)) ret += __print_sign(value, flags); - if(__is_set(flags, HASH_FLAG)) + if (__is_set(flags, HASH_FLAG)) ret += __print_prefix(base); } @@ -325,11 +319,11 @@ static size_t __print_integral(ssize_t value, size_t base, ret += __integral_print(value, base, flags); /* left-justify */ - if(__is_set(flags, ZERO_FLAG)){ - if(pad > 0 && __is_set(flags, LEFT_FLAG)) + if (__is_set(flags, ZERO_FLAG)) { + if (pad > 0 && __is_set(flags, LEFT_FLAG)) ret += __print_padding(pad, '0'); - } else if(__is_set(flags, SPACE_FLAG)) { - if(pad > 0 && __is_set(flags, LEFT_FLAG)) + } else if (__is_set(flags, SPACE_FLAG)) { + if (pad > 0 && __is_set(flags, LEFT_FLAG)) ret += __print_padding(pad, ' '); } @@ -352,16 +346,15 @@ void dbg(const char *fmt, ...) size_t chars_written = 0; - while(*fmt){ - - if (*fmt != '%'){ + while (*fmt) { + if (*fmt != '%') { __putchar(*fmt++); chars_written++; continue; } fmt++; - if(*fmt == '%'){ + if (*fmt == '%') { /* literal percent sign */ __putchar('%'); chars_written++; @@ -373,44 +366,57 @@ void dbg(const char *fmt, ...) size_t flags = 0; int a = STOP; do { - switch(*fmt){ - case ' ': - __set_bit(flags, SPACE_FLAG); fmt++; a = CONT; - break; + switch (*fmt) { + case ' ': + __set_bit(flags, SPACE_FLAG); + fmt++; + a = CONT; + break; - case '-': - __set_bit(flags, LEFT_FLAG); fmt++; a = CONT; - break; + case '-': + __set_bit(flags, LEFT_FLAG); + fmt++; + a = CONT; + break; - case '+': - __set_bit(flags, SIGN_FLAG); fmt++; a = CONT; - break; + case '+': + __set_bit(flags, SIGN_FLAG); + fmt++; + a = CONT; + break; - case '#': - __set_bit(flags, HASH_FLAG); fmt++; a = CONT; - break; + case '#': + __set_bit(flags, HASH_FLAG); + fmt++; + a = CONT; + break; - case '0': __set_bit(flags, ZERO_FLAG); fmt++; a = CONT; - break; + case '0': + __set_bit(flags, ZERO_FLAG); + fmt++; + a = CONT; + break; - case '\'': - __set_bit(flags, FMT_FLAG); fmt++; a = CONT; - break; + case '\'': + __set_bit(flags, FMT_FLAG); + fmt++; + a = CONT; + break; - default: - a = STOP; - break; + default: + a = STOP; + break; } } while (a != STOP); /* check width */ size_t width = 0; - if(__is_digit(*fmt)){ + if (__is_digit(*fmt)) { width = __atoi(fmt++); __set_bit(flags, WIDTH_FLAG | PAD_FLAG | SPACE_FLAG); } else if (*fmt == '*') { int w = va_arg(vl, int); - if(w < 0) { + if (w < 0) { width = -w; __set_bit(flags, LEFT_FLAG); } else { @@ -422,63 +428,62 @@ void dbg(const char *fmt, ...) /* check precision */ size_t precision = 0; - if(*fmt == '.'){ + if (*fmt == '.') { fmt++; __set_bit(flags, PRECS_FLAG | PAD_FLAG | ZERO_FLAG); - if(__is_digit(*fmt)){ + if (__is_digit(*fmt)) { precision = __atoi(fmt++); - } else if(*fmt == '*'){ + } else if (*fmt == '*') { precision = va_arg(vl, int); fmt++; } } /* check length */ - switch(*fmt){ - case 'l': + switch (*fmt) { + case 'l': + fmt++; + if (*fmt == 'l') { + __set_bit(flags, LLONG_FLAG); fmt++; - if (*fmt == 'l'){ - __set_bit(flags, LLONG_FLAG); - fmt++; - } else { - __set_bit(flags, LONG_FLAG); - } - break; + } else { + __set_bit(flags, LONG_FLAG); + } + break; - case 'h': + case 'h': + fmt++; + if (*fmt == 'h') { + __set_bit(flags, CHAR_FLAG); fmt++; - if(*fmt == 'h') { - __set_bit(flags, CHAR_FLAG); - fmt++; - } - else { - __set_bit(flags, SHORT_FLAG); - } - break; + } else { + __set_bit(flags, SHORT_FLAG); + } + break; - case 'j': - fmt++; - if(sizeof(intmax_t) == sizeof(long)) - __set_bit(flags, LONG_FLAG); - else - __set_bit(flags, LLONG_FLAG); - break; + case 'j': + fmt++; + if (sizeof(intmax_t) == sizeof(long)) + __set_bit(flags, LONG_FLAG); + else + __set_bit(flags, LLONG_FLAG); + break; - case 'z': - fmt++; - if(sizeof(size_t) == sizeof(long)) - __set_bit(flags, LONG_FLAG); - else - __set_bit(flags, LLONG_FLAG); - break; + case 'z': + fmt++; + if (sizeof(size_t) == sizeof(long)) + __set_bit(flags, LONG_FLAG); + else + __set_bit(flags, LLONG_FLAG); + break; - case 't': - fmt++; - if(sizeof(ptrdiff_t) == sizeof(long)) - __set_bit(flags, LONG_FLAG); - else - __set_bit(flags, LLONG_FLAG); - break; + case 't': + fmt++; + if (sizeof(ptrdiff_t) == sizeof(long)) + __set_bit(flags, LONG_FLAG); + else + __set_bit(flags, LLONG_FLAG); + break; } /* read actual specifier */ @@ -490,87 +495,95 @@ void dbg(const char *fmt, ...) int *n = 0; char c = 0; - switch(*fmt){ - case 'd': - case 'i': - case 'u': + switch (*fmt) { + case 'd': + case 'i': + case 'u': + case 'x': + case 'X': + case 'o': + case 'b': + /* integer handling */ + switch (*fmt) { case 'x': + base = 16; + break; case 'X': + base = 2; + break; case 'o': - case 'b': - /* integer handling */ - switch(*fmt){ - case 'x': base = 16; break; - case 'X': base = 2; break; - case 'o': base = 8; break; - default : base = 10; break; - } + base = 8; + break; + default: + base = 10; + break; + } - if(base == 10) - __clear_bit(flags, HASH_FLAG); + if (base == 10) + __clear_bit(flags, HASH_FLAG); - /* precision takes precedence */ - if(__is_set(flags, PRECS_FLAG)) - width = precision; + /* precision takes precedence */ + if (__is_set(flags, PRECS_FLAG)) + width = precision; - /* formatting doesn't apply to decimal integers + /* formatting doesn't apply to decimal integers * */ - if(*fmt != 'i' && *fmt != 'd'){ - __clear_bit(flags, SIGN_FLAG); - __set_bit(flags, UNSIGN_FLAG); - } + if (*fmt != 'i' && *fmt != 'd') { + __clear_bit(flags, SIGN_FLAG); + __set_bit(flags, UNSIGN_FLAG); + } - if(__is_set(flags, LLONG_FLAG)) - value = va_arg(vl, long long); - else if(__is_set(flags, LONG_FLAG)) - value = va_arg(vl, long); - else - value = va_arg(vl, int); + if (__is_set(flags, LLONG_FLAG)) + value = va_arg(vl, long long); + else if (__is_set(flags, LONG_FLAG)) + value = va_arg(vl, long); + else + value = va_arg(vl, int); - chars_written += __print_integral(value, base, - flags, width); - fmt++; - break; + chars_written += + __print_integral(value, base, flags, width); + fmt++; + break; - case 'c': - c = va_arg(vl, int); - __putchar(c); - chars_written++; - fmt++; - break; + case 'c': + c = va_arg(vl, int); + __putchar(c); + chars_written++; + fmt++; + break; - case 's': - s = va_arg(vl, const char *); + case 's': + s = va_arg(vl, const char *); - if(__is_set(flags, PRECS_FLAG)) - i = precision; + if (__is_set(flags, PRECS_FLAG)) + i = precision; - for(; *s && i--;){ - __putchar(*s++); - chars_written++; - } - fmt++; - break; + for (; *s && i--;) { + __putchar(*s++); + chars_written++; + } + fmt++; + break; - case 'p': - p = va_arg(vl, void *); - __set_bit(flags, UNSIGN_FLAG | HASH_FLAG); + case 'p': + p = va_arg(vl, void *); + __set_bit(flags, UNSIGN_FLAG | HASH_FLAG); - if(sizeof(void *) == sizeof(long)) - __set_bit(flags, LONG_FLAG); - else - __set_bit(flags, LLONG_FLAG); + if (sizeof(void *) == sizeof(long)) + __set_bit(flags, LONG_FLAG); + else + __set_bit(flags, LLONG_FLAG); - chars_written += __print_integral((ssize_t)p, 16, - flags, width); - fmt++; - break; + chars_written += + __print_integral((ssize_t)p, 16, flags, width); + fmt++; + break; - case 'n': - n = va_arg(vl, int *); - *n = chars_written; - fmt++; - break; + case 'n': + n = va_arg(vl, int *); + *n = chars_written; + fmt++; + break; } } diff --git a/common/dmem.c b/common/dmem.c index 48bcefd..226b3f9 100644 --- a/common/dmem.c +++ b/common/dmem.c @@ -1,7 +1,7 @@ #include <apos/dmem.h> -static struct mem_region_root pre_ram = {0}; -static struct mem_region_root post_ram = {0}; +static struct mem_region_root pre_ram = { 0 }; +static struct mem_region_root post_ram = { 0 }; pm_t __pre_base = 0; pm_t __pre_top = 0; pm_t __post_base = 0; @@ -26,20 +26,23 @@ stat_t init_devmem(pm_t ram_base, pm_t ram_top) return OK; } -stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order) +stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order order) { map_vpage(b, *offset, vaddr, flags, order); *offset += __o_size(order); return OK; } -stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order) +stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order order) { - UNUSED(offset); UNUSED(flags); + UNUSED(offset); + UNUSED(flags); pm_t paddr = 0; enum mm_order v_order = 0; stat_vpage(b, vaddr, &paddr, &v_order, 0); - if(order != v_order) + if (order != v_order) return REGION_TRY_AGAIN; unmap_vpage(b, vaddr); @@ -49,16 +52,17 @@ stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t vm_t alloc_devmem(struct tcb *t, pm_t dev_start, size_t bytes, vmflags_t flags) { vm_t region = 0; - if(dev_start < __pre_top) + if (dev_start < __pre_top) region = alloc_region(&pre_ram, bytes, 0); - if(dev_start > __post_base) + if (dev_start > __post_base) region = alloc_region(&post_ram, bytes, 0); - if(!region) + if (!region) return 0; - return map_fill_region(t->b_r, &dev_alloc_wrapper, dev_start, region, bytes, flags); + return map_fill_region(t->b_r, &dev_alloc_wrapper, dev_start, region, + bytes, flags); } stat_t free_devmem(struct tcb *t, vm_t dev_start) @@ -66,26 +70,27 @@ stat_t free_devmem(struct tcb *t, vm_t dev_start) pm_t dev_paddr = 0; stat_vpage(t->b_r, dev_start, &dev_paddr, 0, 0); - if(dev_paddr >= __pre_top && dev_paddr <= __post_base) + if (dev_paddr >= __pre_top && dev_paddr <= __post_base) return ERR_ADDR; struct mem_region *m = 0; - if(dev_paddr < __pre_top) + if (dev_paddr < __pre_top) m = find_used_region(&pre_ram, dev_paddr); - if(dev_paddr > __post_base) + if (dev_paddr > __post_base) m = find_used_region(&post_ram, dev_paddr); - if(!m) + if (!m) return ERR_NF; size_t region_size = __addr(m->end - m->start); - map_fill_region(t->b_r, &dev_free_wrapper, dev_paddr, dev_start, region_size, 0); + map_fill_region(t->b_r, &dev_free_wrapper, dev_paddr, dev_start, + region_size, 0); - if(dev_paddr < __pre_top) + if (dev_paddr < __pre_top) free_region(&pre_ram, dev_paddr); - if(dev_paddr > __post_base) + if (dev_paddr > __post_base) free_region(&post_ram, dev_paddr); return OK; diff --git a/common/elf.c b/common/elf.c index 9ce357d..ddf61c9 100644 --- a/common/elf.c +++ b/common/elf.c @@ -6,20 +6,21 @@ static uint8_t __elf_to_uvflags(uint8_t elf_flags) { uint8_t uvflags = VM_V | VM_U; - if(elf_flags & PF_X) + if (elf_flags & PF_X) uvflags |= VM_X; - if(elf_flags & PF_W) + if (elf_flags & PF_W) uvflags |= VM_W; - if(elf_flags & PF_R) + if (elf_flags & PF_R) uvflags |= VM_R; return uvflags; } /* useful bit of info: all segments are sorted in ascending order of p_vaddr */ -static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size_t phnum, size_t phsize) +static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, + size_t phnum, size_t phsize) { /* TODO: take alignment into consideration? */ /* TODO: take overlapping memory regions into account, probably mostly @@ -29,21 +30,22 @@ static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size * filled with zeroes. */ /* TODO: in general, make this a low more clean. */ vm_t runner = phstart; - for(size_t i = 0; i < phnum; ++i, runner += phsize){ - if(program_header_prop(ei_c, runner, p_type) != PT_LOAD) + for (size_t i = 0; i < phnum; ++i, runner += phsize) { + if (program_header_prop(ei_c, runner, p_type) != PT_LOAD) continue; vm_t va = program_header_prop(ei_c, runner, p_vaddr); size_t vsz = program_header_prop(ei_c, runner, p_memsz); vm_t start = alloc_fixed_region(&t->sp_r, va, vsz, &vsz); - if(!start) - return; /* out of memory or something */ + if (!start) + return; /* out of memory or something */ uint8_t elf_flags = program_header_prop(ei_c, runner, p_flags); uint8_t uvflags = __elf_to_uvflags(elf_flags); - map_allocd_region(t->b_r, start, vsz, VM_V | VM_X | VM_R | VM_W | VM_U); + map_allocd_region(t->b_r, start, vsz, + VM_V | VM_X | VM_R | VM_W | VM_U); vm_t vo = bin + program_header_prop(ei_c, runner, p_offset); vm_t vfz = program_header_prop(ei_c, runner, p_filesz); @@ -60,7 +62,8 @@ static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size } } -static vm_t __map_dyn(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size_t phnum, size_t phsize) +static vm_t __map_dyn(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, + size_t phnum, size_t phsize) { /* TODO: this path should only be taken when no PT_INTERP is defined, as * making sure ld is loaded should be done in userspace. Maybe a bit @@ -70,7 +73,7 @@ static vm_t __map_dyn(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size_ static vm_t __prepare_proc(struct tcb *t, uint8_t ei_c, vm_t elf) { short e_type = elf_header_prop(ei_c, elf, e_type); - if(e_type != ET_DYN && e_type != ET_EXEC) + if (e_type != ET_DYN && e_type != ET_EXEC) return 0; vm_t phstart = ptradd(elf, elf_header_prop(ei_c, elf, e_phoff)); @@ -78,7 +81,7 @@ static vm_t __prepare_proc(struct tcb *t, uint8_t ei_c, vm_t elf) size_t phsize = elf_header_prop(ei_c, elf, e_phentsize); vm_t entry = elf_header_prop(ei_c, elf, e_entry); - if(e_type == ET_EXEC){ + if (e_type == ET_EXEC) { __map_exec(t, elf, ei_c, phstart, phnum, phsize); return entry; } else { @@ -91,11 +94,11 @@ static vm_t __prepare_proc(struct tcb *t, uint8_t ei_c, vm_t elf) vm_t load_elf(struct tcb *t, vm_t b) { struct elf_ident *i = (struct elf_ident *)b; - if(i->ei_magic != cpu_to_be32(EI_MAGIC)) + if (i->ei_magic != cpu_to_be32(EI_MAGIC)) return 0; - if(i->ei_class != ELFCLASS32 && i->ei_class != ELFCLASS64) - return 0; + if (i->ei_class != ELFCLASS32 && i->ei_class != ELFCLASS64) + return 0; /* more sanity checks? */ return __prepare_proc(t, i->ei_class, b); diff --git a/common/fdt.c b/common/fdt.c index 7cec3a4..56b9d04 100644 --- a/common/fdt.c +++ b/common/fdt.c @@ -2,21 +2,19 @@ struct cell_info get_cellinfo(const void *fdt, const int offset) { - return (struct cell_info){ - fdt_size_cells(fdt, offset), - fdt_address_cells(fdt, offset) - }; + return (struct cell_info){ fdt_size_cells(fdt, offset), + fdt_address_cells(fdt, offset) }; } /* how "reg" is interpreted depends on the parent node */ struct cell_info get_reginfo(const void *fdt, const char *path) { const char *i = strrchr(path, '/'); - if(!i) - return (struct cell_info){0, 0}; + if (!i) + return (struct cell_info){ 0, 0 }; size_t baselen = i - path; - if(i == 0) + if (i == 0) /* root node */ baselen = 1; diff --git a/common/initrd.c b/common/initrd.c index 7b5fa6c..28ddaec 100644 --- a/common/initrd.c +++ b/common/initrd.c @@ -25,28 +25,30 @@ struct __packed cpio_header { static struct cpio_header *__next_entry(struct cpio_header *cp) { - size_t blen = align_up(sizeof(struct cpio_header) + convnum(cp->c_namesize, 8, 16), 4); + size_t blen = align_up( + sizeof(struct cpio_header) + convnum(cp->c_namesize, 8, 16), 4); size_t tlen = align_up(convnum(cp->c_filesize, 8, 16), 4); return (struct cpio_header *)(((char *)cp) + blen + tlen); } -static struct cpio_header *__find_file(const char *c, const char* fname, size_t fname_len) +static struct cpio_header *__find_file(const char *c, const char *fname, + size_t fname_len) { struct cpio_header *cp = (struct cpio_header *)c; - for(; cp; cp = __next_entry(cp)){ + for (; cp; cp = __next_entry(cp)) { size_t namelen = convnum(cp->c_namesize, 8, 16); - if(namelen == 0) + if (namelen == 0) return 0; - if(namelen < fname_len) + if (namelen < fname_len) continue; char *name = (char *)(cp + 1); - if(fname[0] != '/') + if (fname[0] != '/') name += namelen - (fname_len + 1); /* match ending */ - if(strncmp(name, fname, fname_len) == 0) + if (strncmp(name, fname, fname_len) == 0) return cp; } @@ -59,7 +61,7 @@ pm_t get_initrdtop(const void *fdt) struct cell_info ci = get_cellinfo(fdt, chosen_offset); void *initrd_end_ptr = (void *)fdt_getprop(fdt, chosen_offset, - "linux,initrd-end", NULL); + "linux,initrd-end", NULL); /* fdt is only aware of physical memory pointers */ return (pm_t)__va(fdt_load_int_ptr(ci.addr_cells, initrd_end_ptr)); @@ -71,7 +73,7 @@ pm_t get_initrdbase(const void *fdt) const struct cell_info ci = get_cellinfo(fdt, chosen_offset); void *initrd_base_ptr = (void *)fdt_getprop(fdt, chosen_offset, - "linux,initrd-start", NULL); + "linux,initrd-start", NULL); return (pm_t)__va(fdt_load_int_ptr(ci.addr_cells, initrd_base_ptr)); } diff --git a/common/mem.c b/common/mem.c index 7a7eff6..a824c26 100644 --- a/common/mem.c +++ b/common/mem.c @@ -16,9 +16,9 @@ void init_mem(size_t max_order, size_t bits[10], size_t page_shift) __mm_shifts[0] = 0; __mm_widths[0] = 1 << bits[0]; - __mm_sizes[0] = 1 << __mm_page_shift; + __mm_sizes[0] = 1 << __mm_page_shift; - for(size_t i = 1; i <= __mm_max_order; ++i){ + for (size_t i = 1; i <= __mm_max_order; ++i) { __mm_widths[i] = 1 << bits[i]; __mm_shifts[i] = __mm_shifts[i - 1] + bits[i - 1]; __mm_sizes[i] = 1UL << __mm_shifts[i] << __mm_page_shift; diff --git a/common/mem_nodes.c b/common/mem_nodes.c index 099d578..2ab6978 100644 --- a/common/mem_nodes.c +++ b/common/mem_nodes.c @@ -4,9 +4,7 @@ #include <apos/string.h> #include <apos/mem_nodes.h> -enum block_status { - FREE = 0, USED = 1 -}; +enum block_status { FREE = 0, USED = 1 }; struct block_wrapper { enum block_status status; @@ -23,16 +21,16 @@ struct block_region { struct block_region *prev; }; -#define MAX_BLOCKS \ - ((BASE_PAGE_SIZE - sizeof(struct block_region)) / sizeof(struct block_wrapper)) +#define MAX_BLOCKS \ + ((BASE_PAGE_SIZE - sizeof(struct block_region)) / \ + sizeof(struct block_wrapper)) -#define block_region(b) \ +#define block_region(b) \ ((struct block_region *)((size_t)(b) & ~(BASE_PAGE_SIZE - 1))) -#define block_container(b) \ - container_of(b, struct block_wrapper, n) +#define block_container(b) container_of(b, struct block_wrapper, n) -#define region_to_array(r) \ +#define region_to_array(r) \ ((struct block_wrapper *)((char *)(r) + sizeof(struct block_region))) static struct block_region *head = 0; @@ -40,7 +38,8 @@ static struct block_region *av_head = 0; static struct block_region *__create_region() { - struct block_region *r = (struct block_region *)alloc_page(BASE_PAGE, 0); + struct block_region *r = + (struct block_region *)alloc_page(BASE_PAGE, 0); memset(r, FREE, BASE_PAGE_SIZE); return r; } @@ -54,7 +53,7 @@ void init_mem_blocks() void destroy_mem_blocks() { struct block_region *r = head; - while(r){ + while (r) { struct block_region *d = r; r = r->prev; free_page(MM_O0, (pm_t)d); @@ -64,8 +63,8 @@ void destroy_mem_blocks() static struct mem_region *__find_free_block(struct block_region *h) { struct block_wrapper *w = region_to_array(h); - for(size_t i = 0; i < MAX_BLOCKS; ++i){ - if(w[i].status != FREE) + for (size_t i = 0; i < MAX_BLOCKS; ++i) { + if (w[i].status != FREE) continue; w[i].status = USED; @@ -79,7 +78,7 @@ static void __pop_av_head() { struct block_region *t = av_head; av_head = av_head->av_next; - if(av_head) + if (av_head) av_head->av_prev = 0; t->av_next = 0; @@ -88,7 +87,7 @@ static void __pop_av_head() struct mem_region *get_mem_node() { - if(!av_head){ + if (!av_head) { av_head = __create_region(); av_head->prev = head; @@ -99,7 +98,7 @@ struct mem_region *get_mem_node() struct mem_region *ret = __find_free_block(av_head); - if(++av_head->used_blocks == MAX_BLOCKS) + if (++av_head->used_blocks == MAX_BLOCKS) __pop_av_head(); return ret; @@ -109,7 +108,7 @@ static void __push_av_head(struct block_region *r) { r->av_prev = 0; r->av_next = av_head; - if(av_head) + if (av_head) av_head->av_prev = r; av_head = r; @@ -120,26 +119,26 @@ static void __free_block(struct block_region *r) struct block_region *av_n = r->av_next; struct block_region *av_p = r->av_prev; - if(av_n) + if (av_n) av_n->av_prev = av_p; - if(av_p) + if (av_p) av_p->av_next = av_n; - if(r == av_head) + if (r == av_head) __pop_av_head(); struct block_region *n = r->next; struct block_region *p = r->prev; - if(n) + if (n) n->prev = p; - if(p) + if (p) p->next = n; - if(r == head){ - if(head->prev){ + if (r == head) { + if (head->prev) { head->next = 0; head = head->prev; } else @@ -156,11 +155,11 @@ void free_mem_node(struct mem_region *m) struct block_region *r = block_region(w); - if(--r->used_blocks == 0){ + if (--r->used_blocks == 0) { __free_block(r); return; } - else if(!r->av_next && !r->av_prev) + else if (!r->av_next && !r->av_prev) __push_av_head(r); } diff --git a/common/mem_regions.c b/common/mem_regions.c index 7b9b629..975b6b5 100644 --- a/common/mem_regions.c +++ b/common/mem_regions.c @@ -3,9 +3,9 @@ #include <apos/pmem.h> #include <apos/mem.h> -#define mark_region_used(r) ((r) = 1) +#define mark_region_used(r) ((r) = 1) #define mark_region_unused(r) ((r) = 0) -#define region_used(r) (r) +#define region_used(r) (r) /* pretty major slowdown when we get to some really massive numbers, not * entirely sure why. Will need to check up on this at some point, have I @@ -23,31 +23,32 @@ * maybe not even anything with sp_trees but more a weakness of binary trees in * general? */ -static struct mem_region *__insert_free_region(struct mem_region_root *r, struct mem_region *m) +static struct mem_region *__insert_free_region(struct mem_region_root *r, + struct mem_region *m) { struct sp_node *n = sp_root(r->free_regions), *p = NULL; size_t start = m->start; size_t size = m->end - m->start; enum sp_dir d = LEFT; - m->sp_n = (struct sp_node){0}; + m->sp_n = (struct sp_node){ 0 }; - while(n){ + while (n) { struct mem_region *t = mem_container(n); size_t nsize = t->end - t->start; p = n; - if(size < nsize){ + if (size < nsize) { n = sp_left(n); d = LEFT; } - else if(size > nsize) { + else if (size > nsize) { n = sp_right(n); d = RIGHT; } - else if (start < t->start){ + else if (start < t->start) { n = sp_left(n); d = LEFT; } @@ -58,7 +59,7 @@ static struct mem_region *__insert_free_region(struct mem_region_root *r, struct } } - if(sp_root(r->free_regions)) + if (sp_root(r->free_regions)) sp_insert(&sp_root(r->free_regions), p, &m->sp_n, d); else sp_root(r->free_regions) = &m->sp_n; @@ -66,20 +67,21 @@ static struct mem_region *__insert_free_region(struct mem_region_root *r, struct return m; } -static struct mem_region *__insert_used_region(struct mem_region_root *r, struct mem_region *m) +static struct mem_region *__insert_used_region(struct mem_region_root *r, + struct mem_region *m) { struct sp_node *n = sp_root(r->used_regions), *p = NULL; vm_t start = m->start; enum sp_dir d = LEFT; - m->sp_n = (struct sp_node){0}; + m->sp_n = (struct sp_node){ 0 }; - while(n){ + while (n) { struct mem_region *t = mem_container(n); p = n; - if(start < t->start){ + if (start < t->start) { n = sp_left(n); d = LEFT; } @@ -92,7 +94,7 @@ static struct mem_region *__insert_used_region(struct mem_region_root *r, struct } } - if(sp_root(r->used_regions)) + if (sp_root(r->used_regions)) sp_insert(&sp_root(r->used_regions), p, &m->sp_n, d); else sp_root(r->used_regions) = &m->sp_n; @@ -115,7 +117,7 @@ stat_t init_region(struct mem_region_root *r, vm_t start, size_t arena_size) static void __destroy_region(struct sp_node *n) { - if(!n) + if (!n) return; __destroy_region(sp_left(n)); @@ -139,12 +141,12 @@ void destroy_region(struct mem_region_root *r) struct mem_region *find_used_region(struct mem_region_root *r, vm_t start) { struct sp_node *n = sp_root(r->used_regions); - while(n){ + while (n) { struct mem_region *t = mem_container(n); - if(start == t->start) + if (start == t->start) return t; - if(start < t->start) + if (start < t->start) n = sp_left(n); else n = sp_right(n); @@ -154,7 +156,8 @@ struct mem_region *find_used_region(struct mem_region_root *r, vm_t start) } static struct mem_region *create_region(vm_t start, vm_t end, - struct mem_region *prev, struct mem_region *next) + struct mem_region *prev, + struct mem_region *next) { struct mem_region *m = get_mem_node(); m->start = start; @@ -168,35 +171,36 @@ static struct mem_region *create_region(vm_t start, vm_t end, * just from really quick checking */ static size_t po_align(size_t s) { - for(size_t o = __mm_max_order; o > 0; --o){ - if(s >= __o_size(o)) + for (size_t o = __mm_max_order; o > 0; --o) { + if (s >= __o_size(o)) return __o_size(o); } return 0; } -struct mem_region *find_closest_used_region(struct mem_region_root *r, vm_t start) +struct mem_region *find_closest_used_region(struct mem_region_root *r, + vm_t start) { struct mem_region *closest = 0; size_t md = (size_t)(-1); struct sp_node *n = sp_root(r->used_regions); - if(!n) + if (!n) return mem_container(sp_root(r->free_regions)); - while(n){ + while (n) { struct mem_region *t = mem_container(n); size_t d = ABS((ssize_t)start - (ssize_t)t->start); - if(d == 0) /* exact match */ + if (d == 0) /* exact match */ return t; - if(d < md){ /* closest so far */ + if (d < md) { /* closest so far */ closest = t; md = d; } - if(start < t->start) + if (start < t->start) n = sp_left(n); else n = sp_right(n); @@ -212,23 +216,24 @@ struct mem_region *find_closest_used_region(struct mem_region_root *r, vm_t star * still fits in, unaligned. If none of these criteria are met, a NULL is * returned. Note that this does not check *all* possible memory blocks, only * going up in increasing size so as to save time. */ -struct mem_region *find_free_region(struct mem_region_root *r, size_t size, size_t *align) +struct mem_region *find_free_region(struct mem_region_root *r, size_t size, + size_t *align) { *align = 0; size_t offset = __page(po_align(__addr(size))); struct mem_region *quick_best = 0; struct sp_node *n = sp_root(r->free_regions); - while(n){ + while (n) { struct mem_region *t = mem_container(n); vm_t start = align_up(t->start, offset); size_t qsize = t->end - t->start; size_t bsize = t->end - start; - if(!quick_best && size <= qsize) + if (!quick_best && size <= qsize) quick_best = t; - if(size <= bsize){ + if (size <= bsize) { *align = start - t->start; return t; } @@ -240,32 +245,34 @@ struct mem_region *find_free_region(struct mem_region_root *r, size_t size, size } static vm_t __partition_region(struct mem_region_root *r, struct mem_region *m, - size_t pages, size_t align) + size_t pages, size_t align) { sp_remove(&sp_root(r->free_regions), &m->sp_n); vm_t pre_start = m->start; vm_t pre_end = pre_start + align; - + vm_t start = pre_end; vm_t end = start + pages; vm_t post_start = end; vm_t post_end = m->end; - if(pre_start != pre_end){ - struct mem_region *n = create_region(pre_start, pre_end, m->prev, m); + if (pre_start != pre_end) { + struct mem_region *n = + create_region(pre_start, pre_end, m->prev, m); m->prev = n; - if(n->prev) + if (n->prev) n->prev->next = n; __insert_free_region(r, n); } - if(post_start != post_end){ - struct mem_region *n = create_region(post_start, post_end, m, m->next); + if (post_start != post_end) { + struct mem_region *n = + create_region(post_start, post_end, m, m->next); m->next = n; - if(n->next) + if (n->next) n->next->prev = n; __insert_free_region(r, n); @@ -282,8 +289,7 @@ static vm_t __partition_region(struct mem_region_root *r, struct mem_region *m, * just ignore them for now. Note that alloc_region should only be used when * mmap is called with MAP_ANON, all other situations should be handled in some * fs server */ -vm_t alloc_region(struct mem_region_root *r, - size_t size, size_t *actual_size) +vm_t alloc_region(struct mem_region_root *r, size_t size, size_t *actual_size) { *actual_size = align_up(size, BASE_PAGE_SIZE); size_t pages = __page(*actual_size); @@ -291,41 +297,40 @@ vm_t alloc_region(struct mem_region_root *r, /* find best fitting, alignment etc. */ size_t align = 0; struct mem_region *m = find_free_region(r, pages, &align); - if(!m) + if (!m) return 0; return __partition_region(r, m, pages, align); } - -vm_t alloc_fixed_region(struct mem_region_root *r, - vm_t start, size_t size, size_t *actual_size) +vm_t alloc_fixed_region(struct mem_region_root *r, vm_t start, size_t size, + size_t *actual_size) { size_t asize = align_up(size, BASE_PAGE_SIZE); - if(actual_size) + if (actual_size) *actual_size = asize; size_t pages = __page(asize); start = __page(start); struct mem_region *m = find_closest_used_region(r, start); - if(!m) + if (!m) return 0; /* locate actual region where start is between the region start and end */ - while(!((m->start <= start) && (start <= m->end))){ - if(start > m->start) + while (!((m->start <= start) && (start <= m->end))) { + if (start > m->start) m = m->next; else m = m->prev; } /* if region is already in use, forget it */ - if(region_used(m->flags)) + if (region_used(m->flags)) return 0; /* region is too small */ - if(start + pages > m->end) + if (start + pages > m->end) return 0; /* actually start marking region used */ @@ -334,18 +339,18 @@ vm_t alloc_fixed_region(struct mem_region_root *r, static void __try_coalesce_prev(struct mem_region_root *r, struct mem_region *m) { - while(m){ - if(!m || region_used(m->flags)) + while (m) { + if (!m || region_used(m->flags)) return; struct mem_region *p = m->prev; - if(!p || region_used(p->flags)) + if (!p || region_used(p->flags)) return; m->start = p->start; m->prev = p->prev; - if(m->prev) + if (m->prev) m->prev->next = m; sp_remove(&sp_root(r->free_regions), &p->sp_n); @@ -357,18 +362,18 @@ static void __try_coalesce_prev(struct mem_region_root *r, struct mem_region *m) static void __try_coalesce_next(struct mem_region_root *r, struct mem_region *m) { - while(m){ - if(!m || region_used(m->flags)) + while (m) { + if (!m || region_used(m->flags)) return; struct mem_region *n = m->next; - if(!n || region_used(n->flags)) + if (!n || region_used(n->flags)) return; m->end = n->end; m->next = n->next; - if(m->next) + if (m->next) m->next->prev = m; sp_remove(&sp_root(r->free_regions), &n->sp_n); @@ -378,7 +383,8 @@ static void __try_coalesce_next(struct mem_region_root *r, struct mem_region *m) } } -static void __try_coalesce_regions(struct mem_region_root *r, struct mem_region *m) +static void __try_coalesce_regions(struct mem_region_root *r, + struct mem_region *m) { __try_coalesce_prev(r, m); __try_coalesce_next(r, m); @@ -387,11 +393,11 @@ static void __try_coalesce_regions(struct mem_region_root *r, struct mem_region stat_t free_region(struct mem_region_root *r, vm_t start) { /* addr not aligned to page boundary, corrupted or incorrect pointer */ - if(!aligned(start, BASE_PAGE_SIZE)) + if (!aligned(start, BASE_PAGE_SIZE)) return ERR_ALIGN; struct mem_region *m = find_used_region(r, __page(start)); - if(!m) + if (!m) return ERR_NF; sp_remove(&sp_root(r->used_regions), &m->sp_n); @@ -409,7 +415,7 @@ stat_t free_region(struct mem_region_root *r, vm_t start) * permutations etc. which would be slow and I don't want to implement it. */ vm_t map_fill_region(struct vm_branch *b, region_callback_t *mem_handler, - pm_t offset, vm_t start, size_t bytes, vmflags_t flags) + pm_t offset, vm_t start, size_t bytes, vmflags_t flags) { pm_t runner = __page(start); size_t pages = __pages(bytes); @@ -418,22 +424,23 @@ vm_t map_fill_region(struct vm_branch *b, region_callback_t *mem_handler, /* actual start might not be the same as the user specified start */ start = __addr(runner); - for(; pages; top--){ + for (; pages; top--) { size_t o_size = __o_size(top); size_t o_pages = __pages(o_size); /* NULL does pass this check, so technically all NULL pages are * aligned, but they're caught in the while expr so this should * work even if someone tries to map NULL */ - if(!aligned(runner, o_pages)) + if (!aligned(runner, o_pages)) continue; - while(pages >= o_pages){ - stat_t res = mem_handler(b, &offset, __addr(runner), flags, top); - if(res > 0) + while (pages >= o_pages) { + stat_t res = mem_handler(b, &offset, __addr(runner), + flags, top); + if (res > 0) break; - if(res < 0) + if (res < 0) return 0; pages -= o_pages; diff --git a/common/pmem.c b/common/pmem.c index 4c965cf..6ef89bc 100644 --- a/common/pmem.c +++ b/common/pmem.c @@ -8,25 +8,28 @@ #include <libfdt.h> /* NOTE: these are all for pnum_t, i.e. O0_SHIFT is from 0 */ -#define __foreach_page(var, start, end, attr, neg)\ - for(size_t i = num_indexes(start); i < num_elems(end); ++i)\ - if(var->attr[i] == (mm_info_t)(-1)) continue;\ - else for(pnum_t page = i * MM_OINFO_WIDTH, j = 0;\ - j < (pnum_t)MIN((end) - i * MM_OINFO_WIDTH, MM_OINFO_WIDTH);\ - ++j, ++page)\ - if(neg(__is_nset(var->attr[i], j))) +#define __foreach_page(var, start, end, attr, neg) \ + for (size_t i = num_indexes(start); i < num_elems(end); ++i) \ + if (var->attr[i] == (mm_info_t)(-1)) \ + continue; \ + else \ + for (pnum_t page = i * MM_OINFO_WIDTH, j = 0; \ + j < (pnum_t)MIN((end)-i * MM_OINFO_WIDTH, \ + MM_OINFO_WIDTH); \ + ++j, ++page) \ + if (neg(__is_nset(var->attr[i], j))) #define NEG ! -#define foreach_full_page(var, start, order)\ +#define foreach_full_page(var, start, order) \ __foreach_page(var, start, var->entries, full, ) -#define foreach_not_full_page(var, start, order)\ +#define foreach_not_full_page(var, start, order) \ __foreach_page(var, start, var->entries, full, NEG) -#define foreach_used_page(var, start, order)\ +#define foreach_used_page(var, start, order) \ __foreach_page(var, start, var->entries, used, ) -#define foreach_not_used_page(var, start, order)\ +#define foreach_not_used_page(var, start, order) \ __foreach_page(var, start, var->entries, used, NEG) typedef uint32_t mm_info_t; @@ -55,8 +58,8 @@ struct mm_pmap_t { static struct mm_pmap_t *pmap = 0; -static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order tgt, - enum mm_order src, enum mm_order dst) +static void __mark_free(mm_node_t *op, pnum_t pnum, enum mm_order tgt, + enum mm_order src, enum mm_order dst) { size_t idx = pnum_to_index(pnum, src); @@ -67,7 +70,7 @@ static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order tgt, } struct mm_branch_t *o = (struct mm_branch_t *)op; - if(src != tgt) + if (src != tgt) __mark_free(o->next[idx], pnum, tgt, src - 1, dst); /* freeing a page results in always clearing a full bit? */ @@ -87,15 +90,15 @@ void free_page(enum mm_order order, pm_t paddr) for (size_t j = 0; j < omap->order; ++j) __mark_free(omap->orders[j], - pm_to_pnum(paddr - omap->base), - order, omap->order, j); + pm_to_pnum(paddr - omap->base), order, + omap->order, j); return; } } -static bool __mark_used(mm_node_t * op, pnum_t pnum, enum mm_order tgt, - enum mm_order src, enum mm_order dst) +static bool __mark_used(mm_node_t *op, pnum_t pnum, enum mm_order tgt, + enum mm_order src, enum mm_order dst) { size_t idx = pnum_to_index(pnum, src); @@ -141,21 +144,22 @@ void mark_used(enum mm_order order, pm_t paddr) for (size_t j = 0; j <= omap->order; ++j) __mark_used(omap->orders[j], - pm_to_pnum(paddr - omap->base), - order, omap->order, j); + pm_to_pnum(paddr - omap->base), order, + omap->order, j); return; } } -static pnum_t __enum_order(mm_node_t * op, pnum_t offset, - enum mm_order src, enum mm_order dst) +static pnum_t __enum_order(mm_node_t *op, pnum_t offset, enum mm_order src, + enum mm_order dst) { size_t idx = pnum_to_index(offset, src); if (src == dst) { struct mm_leaf_t *o = (struct mm_leaf_t *)op; - foreach_not_used_page(o, idx, src) { + foreach_not_used_page(o, idx, src) + { return page << __o_offset(src); } @@ -163,11 +167,12 @@ static pnum_t __enum_order(mm_node_t * op, pnum_t offset, } struct mm_branch_t *o = (struct mm_branch_t *)op; - foreach_not_full_page(o, idx, src) { + foreach_not_full_page(o, idx, src) + { /* if the suggested search index is full, the following level * would get an incorrect offset if trying to follow the original * suggestion. */ - if (page != (pnum_t) idx) + if (page != (pnum_t)idx) offset = 0; pnum_t ret = __enum_order(o->next[page], offset, src - 1, dst); @@ -195,8 +200,8 @@ pm_t alloc_page(enum mm_order order, pm_t offset) if (offset != 0) base = offset - omap->base; - pnum = __enum_order(omap->orders[order], - pm_to_pnum(base), omap->order, order); + pnum = __enum_order(omap->orders[order], pm_to_pnum(base), + omap->order, order); if (!(pnum < 0)) break; @@ -211,43 +216,43 @@ pm_t alloc_page(enum mm_order order, pm_t offset) } /* unfortunate that populating the mm info is so complicated */ -static pm_t __populate_order(mm_node_t ** op, pm_t cont, - enum mm_order src, enum mm_order dst, size_t num) +static pm_t __populate_order(mm_node_t **op, pm_t cont, enum mm_order src, + enum mm_order dst, size_t num) { if (src == dst) { - struct mm_leaf_t *o = (struct mm_leaf_t *) - move_forward(cont, sizeof(struct mm_leaf_t)); + struct mm_leaf_t *o = (struct mm_leaf_t *)move_forward( + cont, sizeof(struct mm_leaf_t)); o->entries = num; - o->used = (mm_info_t *) move_forward(cont, state_elems(num)); + o->used = (mm_info_t *)move_forward(cont, state_elems(num)); memset(o->used, 0, state_elems(num)); - *op = (mm_node_t *) o; + *op = (mm_node_t *)o; return cont; } - struct mm_branch_t *o = (struct mm_branch_t *) - move_forward(cont, sizeof(struct mm_branch_t)); + struct mm_branch_t *o = (struct mm_branch_t *)move_forward( + cont, sizeof(struct mm_branch_t)); o->entries = num; - o->full = (mm_info_t *) move_forward(cont, state_elems(num)); - o->next = (mm_node_t **) move_forward(cont, next_elems(num)); + o->full = (mm_info_t *)move_forward(cont, state_elems(num)); + o->next = (mm_node_t **)move_forward(cont, next_elems(num)); memset(o->full, 0, state_elems(num)); memset(o->next, 0, next_elems(num)); for (size_t i = 0; i < num; ++i) { - cont = __populate_order(&o->next[i], cont, - src - 1, dst, __o_width(src - 1)); + cont = __populate_order(&o->next[i], cont, src - 1, dst, + __o_width(src - 1)); } - *op = (mm_node_t *) o; + *op = (mm_node_t *)o; return cont; } static pm_t __probe_order(pm_t cont, enum mm_order src, enum mm_order dst, - size_t num) + size_t num) { - if(src == dst){ + if (src == dst) { cont += sizeof(struct mm_leaf_t); cont += state_elems(num); return cont; @@ -257,29 +262,29 @@ static pm_t __probe_order(pm_t cont, enum mm_order src, enum mm_order dst, cont += state_elems(num); cont += next_elems(num); - for(size_t i = 0; i < num; ++i) + for (size_t i = 0; i < num; ++i) cont = __probe_order(cont, src - 1, dst, __o_width(src - 1)); return cont; } -static pm_t __populate_omap(struct mm_omap_t **omap, pm_t cont, - pm_t base, size_t entries, enum mm_order order) +static pm_t __populate_omap(struct mm_omap_t **omap, pm_t cont, pm_t base, + size_t entries, enum mm_order order) { - struct mm_omap_t *lomap = (struct mm_omap_t *) - move_forward(cont, sizeof(struct mm_omap_t)); + struct mm_omap_t *lomap = (struct mm_omap_t *)move_forward( + cont, sizeof(struct mm_omap_t)); memset(lomap, 0, sizeof(struct mm_omap_t)); - lomap->orders = (mm_node_t **) move_forward(cont, - (order + 1) * sizeof(mm_node_t **)); + lomap->orders = (mm_node_t **)move_forward( + cont, (order + 1) * sizeof(mm_node_t **)); memset(lomap->orders, 0, (order + 1) * sizeof(mm_node_t **)); lomap->order = order; lomap->base = base; for (size_t i = 0; i <= order; ++i) - cont = __populate_order(&lomap->orders[i], cont, - order, i, entries); + cont = __populate_order(&lomap->orders[i], cont, order, i, + entries); *omap = lomap; return cont; @@ -290,7 +295,7 @@ static pm_t __probe_omap(pm_t cont, size_t entries, enum mm_order order) cont += sizeof(struct mm_omap_t); cont += (order + 1) * sizeof(mm_node_t **); - for(size_t i = 0; i <= order; ++i) + for (size_t i = 0; i <= order; ++i) cont = __probe_order(cont, order, i, entries); return cont; @@ -310,8 +315,8 @@ pm_t populate_pmap(pm_t ram_base, size_t ram_size, pm_t cont) if (entries == 0) continue; - cont = __populate_omap(&pmap->omap[i], cont, - ram_region, entries, i); + cont = __populate_omap(&pmap->omap[i], cont, ram_region, + entries, i); ram_left -= __mm_sizes[i] * entries; ram_region += (__mm_sizes[i] * entries); @@ -332,9 +337,9 @@ pm_t probe_pmap(pm_t ram_base, size_t ram_size) pm_t ram_region = ram_base; size_t ram_left = ram_size; - for(ssize_t i = __mm_max_order; i >= MM_O0; --i){ + for (ssize_t i = __mm_max_order; i >= MM_O0; --i) { size_t entries = ram_left / __mm_sizes[i]; - if(entries == 0) + if (entries == 0) continue; cont = __probe_omap(cont, entries, i); @@ -350,13 +355,13 @@ static void __mark_area_used(pm_t base, pm_t top) { size_t area_left = top - base; pm_t runner = base; - while(area_left >= BASE_PAGE_SIZE){ + while (area_left >= BASE_PAGE_SIZE) { mark_used(BASE_PAGE, runner); runner += BASE_PAGE_SIZE; area_left -= BASE_PAGE_SIZE; } - if(area_left != 0) + if (area_left != 0) mark_used(BASE_PAGE, runner); } @@ -364,11 +369,12 @@ static void __mark_reserved_mem(void *fdt) { int rmem_offset = fdt_path_offset(fdt, "/reserved-memory/mmode_resv0"); struct cell_info ci = get_reginfo(fdt, "/reserved-memory/mmode_resv0"); - uint8_t *rmem_reg = (uint8_t *)fdt_getprop(fdt, rmem_offset, "reg", NULL); + uint8_t *rmem_reg = + (uint8_t *)fdt_getprop(fdt, rmem_offset, "reg", NULL); pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, rmem_reg); - if(ci.addr_cells == 2) + if (ci.addr_cells == 2) rmem_reg += sizeof(fdt64_t); else rmem_reg += sizeof(fdt32_t); @@ -385,7 +391,7 @@ static pm_t __get_ramtop(void *fdt) pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, mem_reg); - if(ci.addr_cells == 2) + if (ci.addr_cells == 2) mem_reg += sizeof(fdt64_t); else mem_reg += sizeof(fdt32_t); @@ -409,7 +415,7 @@ void init_pmem(void *fdt) { size_t max_order = 0; size_t base_bits = 0; - size_t bits[NUM_ORDERS] = {0}; + size_t bits[NUM_ORDERS] = { 0 }; stat_pmem_conf(fdt, &max_order, &base_bits, bits); init_mem(max_order, bits, base_bits); @@ -426,9 +432,9 @@ void init_pmem(void *fdt) size_t probe_size = probe_pmap(ram_base, ram_size); size_t actual_size = populate_pmap(ram_base, ram_size, pmap_base); - if(probe_size != actual_size) - bug("probe_size (%#lx) != actual_size (%#lx)\n", - probe_size, actual_size); + if (probe_size != actual_size) + bug("probe_size (%#lx) != actual_size (%#lx)\n", probe_size, + actual_size); /* mark init stack, this should be unmapped once we get to executing * processes */ diff --git a/common/proc.c b/common/proc.c index 13d3750..9f89b7f 100644 --- a/common/proc.c +++ b/common/proc.c @@ -11,10 +11,10 @@ static vm_t setup_call_stack(struct tcb *t, size_t bytes) pm_t offset = 0; size_t pages = __pages(bytes); vmflags_t flags = VM_V | VM_R | VM_W | VM_U; - for(size_t i = 1; i <= pages; ++i) - { + for (size_t i = 1; i <= pages; ++i) { offset = alloc_page(BASE_PAGE, offset); - map_vpage(t->b_r, offset, PROC_STACK_TOP - BASE_PAGE_SIZE * i, flags, BASE_PAGE); + map_vpage(t->b_r, offset, PROC_STACK_TOP - BASE_PAGE_SIZE * i, + flags, BASE_PAGE); } return PROC_STACK_TOP - BASE_PAGE_SIZE * pages; @@ -29,7 +29,7 @@ stat_t init_proc(void *fdt, struct vm_branch *b) { /* todo: cleanup or something */ struct tcb *t = (struct tcb *)alloc_page(BASE_PAGE, 0); - if(!t) + if (!t) return ERR_OOMEM; memset(t, 0, sizeof(struct tcb)); @@ -43,18 +43,17 @@ stat_t init_proc(void *fdt, struct vm_branch *b) /* the binary gets to choose first what memory regions it requires */ t->entry = load_elf(t, get_init_base(fdt)); - if(!t->entry) + if (!t->entry) return ERR_ADDR; t->proc_stack = setup_proc_stack(t, __proc_stack_size); - if(!t->proc_stack) + if (!t->proc_stack) return ERR_ADDR; t->call_stack = setup_call_stack(t, __call_stack_size); - if(!t->call_stack) + if (!t->call_stack) return ERR_ADDR; - flush_tlb(); /* TODO: move fdt into process space */ diff --git a/common/sp_tree.c b/common/sp_tree.c index 495b843..5097757 100644 --- a/common/sp_tree.c +++ b/common/sp_tree.c @@ -10,12 +10,12 @@ static void __sp_turn_left(struct sp_node *n) sp_paren(n) = l; sp_right(l) = n; - if(p && sp_left(p) == n) + if (p && sp_left(p) == n) sp_left(p) = l; else if (p) sp_right(p) = l; - if(sp_left(n)) + if (sp_left(n)) sp_lparen(n) = n; } @@ -29,12 +29,12 @@ static void __sp_turn_right(struct sp_node *n) sp_paren(n) = r; sp_left(r) = n; - if(p && sp_left(p) == n) + if (p && sp_left(p) == n) sp_left(p) = r; else if (p) sp_right(p) = r; - if(sp_right(n)) + if (sp_right(n)) sp_rparen(n) = n; } @@ -43,10 +43,10 @@ static int __sp_balance(struct sp_node *n) int l = 0; int r = 0; - if(sp_left(n)) + if (sp_left(n)) l = sp_left(n)->hint + 1; - if(sp_right(n)) + if (sp_right(n)) r = sp_right(n)->hint + 1; return l - r; @@ -57,13 +57,13 @@ static int __sp_max_hint(struct sp_node *n) int l = 0; int r = 0; - if(sp_left(n)) + if (sp_left(n)) l = sp_left(n)->hint + 1; - if(sp_right(n)) + if (sp_right(n)) r = sp_right(n)->hint + 1; - if(l > r) + if (l > r) return l; else return r; @@ -71,45 +71,44 @@ static int __sp_max_hint(struct sp_node *n) static void __sp_update(struct sp_node **root, struct sp_node *n) { - while(n){ - + while (n) { int b = __sp_balance(n); int prev_hint = n->hint; struct sp_node *p = sp_paren(n); - if(b < -1) { + if (b < -1) { /* leaning to the right */ - if(n == *root) + if (n == *root) *root = sp_right(n); __sp_turn_right(n); } - else if(b > 1){ + else if (b > 1) { /* leaning to the left */ - if(n == *root) + if (n == *root) *root = sp_left(n); __sp_turn_left(n); } n->hint = __sp_max_hint(n); - if(n->hint == 0 || n->hint != prev_hint) + if (n->hint == 0 || n->hint != prev_hint) n = p; else return; } } -void sp_insert(struct sp_node **root, struct sp_node *p, - struct sp_node *n, enum sp_dir d) +void sp_insert(struct sp_node **root, struct sp_node *p, struct sp_node *n, + enum sp_dir d) { - if(!*root){ + if (!*root) { *root = n; return; } - if(d == LEFT) + if (d == LEFT) sp_left(p) = n; else sp_right(p) = n; @@ -123,29 +122,29 @@ static void __sp_replace_right(struct sp_node *n, struct sp_node *r) struct sp_node *p = sp_paren(n); struct sp_node *rp = sp_paren(r); - if(sp_left(rp) == r){ + if (sp_left(rp) == r) { sp_left(rp) = sp_right(r); - if(sp_right(r)) + if (sp_right(r)) sp_rparen(r) = rp; } - if(sp_paren(rp) == n) + if (sp_paren(rp) == n) sp_paren(rp) = r; sp_paren(r) = p; sp_left(r) = sp_left(n); - if(sp_right(n) != r){ + if (sp_right(n) != r) { sp_right(r) = sp_right(n); sp_rparen(n) = r; } - if(p && sp_left(p) == n) + if (p && sp_left(p) == n) sp_left(p) = r; else if (p) sp_right(p) = r; - if(sp_left(n)) + if (sp_left(n)) sp_lparen(n) = r; } @@ -154,39 +153,39 @@ static void __sp_replace_left(struct sp_node *n, struct sp_node *l) struct sp_node *p = sp_paren(n); struct sp_node *lp = sp_paren(l); - if(sp_right(lp) == l){ + if (sp_right(lp) == l) { sp_right(lp) = sp_left(l); - if(sp_left(l)) + if (sp_left(l)) sp_lparen(l) = lp; } - if(sp_paren(lp) == n) + if (sp_paren(lp) == n) sp_paren(lp) = l; sp_paren(l) = p; sp_right(l) = sp_right(n); - if(sp_left(n) != l){ + if (sp_left(n) != l) { sp_left(l) = sp_left(n); sp_lparen(n) = l; } - if(p && sp_left(p) == n) + if (p && sp_left(p) == n) sp_left(p) = l; else if (p) sp_right(p) = l; - if(sp_right(n)) + if (sp_right(n)) sp_rparen(n) = l; } /* TODO: handle root better */ void sp_remove(struct sp_node **root, struct sp_node *del) { - if(sp_right(del)){ + if (sp_right(del)) { struct sp_node *least = sp_first(sp_right(del)); - if(del == *root) + if (del == *root) *root = least; __sp_replace_right(del, least); @@ -194,10 +193,10 @@ void sp_remove(struct sp_node **root, struct sp_node *del) return; } - if(sp_left(del)){ + if (sp_left(del)) { struct sp_node *most = sp_last(sp_left(del)); - if(del == *root) + if (del == *root) *root = most; __sp_replace_left(del, most); @@ -205,7 +204,7 @@ void sp_remove(struct sp_node **root, struct sp_node *del) return; } - if(del == *root){ + if (del == *root) { *root = 0; return; } @@ -213,7 +212,7 @@ void sp_remove(struct sp_node **root, struct sp_node *del) /* empty node */ struct sp_node *paren = sp_paren(del); - if(sp_left(paren) == del) + if (sp_left(paren) == del) sp_left(paren) = 0; else sp_right(paren) = 0; @@ -223,14 +222,16 @@ void sp_remove(struct sp_node **root, struct sp_node *del) struct sp_node *sp_first(struct sp_node *n) { - if(!sp_left(n)) return n; + if (!sp_left(n)) + return n; return sp_first(sp_left(n)); } struct sp_node *sp_last(struct sp_node *n) { - if(!sp_right(n)) return n; + if (!sp_right(n)) + return n; return sp_last(sp_right(n)); } diff --git a/common/string.c b/common/string.c index 810a703..15416af 100644 --- a/common/string.c +++ b/common/string.c @@ -73,7 +73,8 @@ __weak int strcmp(const char *str1, const char *str2) const char *s1 = (const char *)str1; const char *s2 = (const char *)str2; - while ((*(s1++) == *(s2++)) && *s1 && *s2) ; + while ((*(s1++) == *(s2++)) && *s1 && *s2) + ; return (int)(s1[-1] - s2[-1]); } @@ -84,7 +85,8 @@ __weak int strncmp(const char *str1, const char *str2, size_t num) const char *s1 = (const char *)str1; const char *s2 = (const char *)str2; - while ((*(s1++) == *(s2++)) && *s1 && *s2 && --num) ; + while ((*(s1++) == *(s2++)) && *s1 && *s2 && --num) + ; return (int)(s1[-1] - s2[-1]); } @@ -95,7 +97,8 @@ __weak char *strchr(const char *str, int chr) const char *s1 = str; ssize_t num = strlen(s1); - while (num-- && *(s1--) != chr) ; + while (num-- && *(s1--) != chr) + ; if (num < 0) return 0; @@ -164,7 +167,8 @@ __weak char *strrchr(const char *str, int chr) ssize_t num = strlen(str); const char *s1 = (str + num) - 1; - while (num-- && *(s1--) != chr) ; + while (num-- && *(s1--) != chr) + ; if (num < 0) return 0; @@ -229,7 +233,8 @@ __weak size_t strspn(const char *str1, const char *str2) __weak size_t strlen(const char *str) { const char *s1 = str; - while (*(s1++)) ; + while (*(s1++)) + ; /* the loop overshoots by one */ return (size_t)(s1 - str) - 1; @@ -239,7 +244,8 @@ __weak size_t strlen(const char *str) __weak size_t strnlen(const char *str, size_t num) { const char *s1 = str; - while (num-- && *(s1++)) ; + while (num-- && *(s1++)) + ; return (size_t)(s1 - str) - 1; } @@ -263,7 +269,8 @@ __weak void *memchr(const void *ptr, int val, size_t num) ssize_t n = num; char c = (char)val; - while (n-- && *(p1++) != c) ; + while (n-- && *(p1++) != c) + ; if (n < 0) return 0; @@ -304,8 +311,8 @@ __weak int memcmp(const void *ptr1, const void *ptr2, size_t num) const char *p1 = (const char *)ptr1; const char *p2 = (const char *)ptr2; - while ((*(p1++) == *(p2++)) && --num) ; + while ((*(p1++) == *(p2++)) && --num) + ; return (int)(p1[-1] - p2[-1]); } - diff --git a/common/tcb.c b/common/tcb.c index 8fea188..cd946bd 100644 --- a/common/tcb.c +++ b/common/tcb.c @@ -3,15 +3,14 @@ #include <apos/sp_tree.h> #include <arch/cpu.h> -static struct sp_root t_root = (struct sp_root){0}; -static struct tcb *__tcb_cache[MAX_CPUS] = {0}; +static struct sp_root t_root = (struct sp_root){ 0 }; +static struct tcb *__tcb_cache[MAX_CPUS] = { 0 }; -#define tcb_container(x) \ - container_of(x, struct tcb, sp_n) +#define tcb_container(x) container_of(x, struct tcb, sp_n) stat_t threads_insert(struct tcb *t) { - if(!sp_root(t_root)){ + if (!sp_root(t_root)) { sp_root(t_root) = &t->sp_n; return OK; } @@ -19,11 +18,11 @@ stat_t threads_insert(struct tcb *t) struct sp_node *n = sp_root(t_root), *p = NULL; enum sp_dir d = LEFT; - while(n){ + while (n) { struct tcb *tc = tcb_container(n); p = n; - if(t->tid < tc->tid){ + if (t->tid < tc->tid) { n = sp_left(n); d = LEFT; } @@ -42,13 +41,13 @@ struct tcb *threads_find(id_t tid) { struct sp_node *n = sp_root(t_root); - while(n){ + while (n) { struct tcb *t = tcb_container(n); - if(t->tid == tid) + if (t->tid == tid) return t; - if(t->tid < tid) + if (t->tid < tid) n = sp_left(n); else n = sp_right(n); diff --git a/common/uapi/conf.c b/common/uapi/conf.c index 6f4faff..56e07a1 100644 --- a/common/uapi/conf.c +++ b/common/uapi/conf.c @@ -6,14 +6,17 @@ size_t __call_stack_size = SZ_2M; vm_t sys_conf(vm_t param, vm_t val, vm_t u0, vm_t u1) { - UNUSED(u0); UNUSED(u1); + UNUSED(u0); + UNUSED(u1); /* no parameters supported atm */ return 0; } vm_t sys_poweroff(vm_t type, vm_t u0, vm_t u1, vm_t u2) { - UNUSED(u0); UNUSED(u1); UNUSED(u2); + UNUSED(u0); + UNUSED(u1); + UNUSED(u2); /* powering off not supported yet, you're stuck here >:D */ return 0; } diff --git a/common/uapi/ipc.c b/common/uapi/ipc.c index 5abbaeb..a3b29f8 100644 --- a/common/uapi/ipc.c +++ b/common/uapi/ipc.c @@ -3,9 +3,11 @@ vm_t sys_ipc_server(vm_t callback, vm_t u0, vm_t u1, vm_t u2) { - UNUSED(u0); UNUSED(u1); UNUSED(u2); + UNUSED(u0); + UNUSED(u1); + UNUSED(u2); struct tcb *r = cur_tcb(); - if(r->callback) /* server can't be reinitialized */ + if (r->callback) /* server can't be reinitialized */ return 1; r->callback = callback; @@ -21,7 +23,8 @@ vm_t sys_ipc_req(vm_t pid, vm_t d0, vm_t d1, vm_t d2) vm_t sys_ipc_resp(vm_t pid, vm_t ret, vm_t u0, vm_t u1) { - UNUSED(u0); UNUSED(u1); + UNUSED(u0); + UNUSED(u1); struct tcb *r = get_tcb(pid); /* something like return_from_callback(t, r) */ return 0; /* oh yeah probably unreachable? */ diff --git a/common/uapi/mem.c b/common/uapi/mem.c index 0a88eda..f54131f 100644 --- a/common/uapi/mem.c +++ b/common/uapi/mem.c @@ -5,7 +5,8 @@ vm_t sys_req_mem(vm_t size, vm_t flags, vm_t u0, vm_t u1) { - UNUSED(u0); UNUSED(u1); + UNUSED(u0); + UNUSED(u1); /* proc_tcb should give the tcb of the TID currently running */ struct tcb *r = cur_tcb(); return alloc_uvmem(r, size, flags); @@ -20,9 +21,11 @@ vm_t sys_req_fixmem(vm_t start, vm_t size, vm_t flags, vm_t u0) vm_t sys_free_mem(vm_t start, vm_t u0, vm_t u1, vm_t u2) { - UNUSED(u0); UNUSED(u1); UNUSED(u2); + UNUSED(u0); + UNUSED(u1); + UNUSED(u2); struct tcb *r = cur_tcb(); - if(start > __pre_top && start < __post_base) + if (start > __pre_top && start < __post_base) free_uvmem(r, start); else free_devmem(r, start); diff --git a/common/uapi/proc.c b/common/uapi/proc.c index dd05bad..e4673b5 100644 --- a/common/uapi/proc.c +++ b/common/uapi/proc.c @@ -12,7 +12,9 @@ */ vm_t sys_fork(vm_t pid, vm_t u0, vm_t u1, vm_t u2) { - UNUSED(u0); UNUSED(u1); UNUSED(u2); + UNUSED(u0); + UNUSED(u1); + UNUSED(u2); /* TODO: create new thread in the same process family */ return 0; } @@ -25,21 +27,25 @@ vm_t sys_exec(vm_t pid, vm_t bin, vm_t argc, vm_t argv) vm_t sys_signal(vm_t pid, vm_t signal, vm_t u0, vm_t u1) { - UNUSED(u0); UNUSED(u1); + UNUSED(u0); + UNUSED(u1); /* TODO: signals? */ return 0; } vm_t sys_switch(vm_t pid, vm_t u0, vm_t u1, vm_t u2) { - UNUSED(u0); UNUSED(u1); UNUSED(u2); + UNUSED(u0); + UNUSED(u1); + UNUSED(u2); /* TODO: switch to process */ return 0; } vm_t sys_sync(vm_t buf, vm_t size, vm_t u0, vm_t u1) { - UNUSED(u0); UNUSED(u1); + UNUSED(u0); + UNUSED(u1); /* check that only the process manager can use this syscall, otherwise * just dump process info into the buffer (I guess, not sure if this * will be quite required */ diff --git a/common/vmem.c b/common/vmem.c index fe77634..d0d40ec 100644 --- a/common/vmem.c +++ b/common/vmem.c @@ -22,7 +22,7 @@ vm_t alloc_fixed_uvmem(struct tcb *t, vm_t start, size_t size, vmflags_t flags) stat_t free_uvmem(struct tcb *t, vm_t va) { struct mem_region *m = find_used_region(&t->sp_r, va); - if(!m) + if (!m) return -1; pm_t pa = __addr(m->end - m->start); @@ -32,24 +32,27 @@ stat_t free_uvmem(struct tcb *t, vm_t va) return 0; } -stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order) +stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order order) { *offset = alloc_page(order, *offset); - if(!*offset) + if (!*offset) return REGION_TRY_AGAIN; /* try again */ map_vpage(b, *offset, vaddr, flags, order); return OK; } -stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order) +stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order order) { - UNUSED(flags); UNUSED(offset); + UNUSED(flags); + UNUSED(offset); pm_t paddr = 0; enum mm_order v_order = 0; stat_vpage(b, vaddr, &paddr, &v_order, 0); - if(order != v_order) + if (order != v_order) return REGION_TRY_AGAIN; unmap_vpage(b, vaddr); diff --git a/include/apos/atomic.h b/include/apos/atomic.h index 1b92100..e6dafc8 100644 --- a/include/apos/atomic.h +++ b/include/apos/atomic.h @@ -3,8 +3,7 @@ #include <apos/utils.h> /* GLUE */ -typedef enum -{ +typedef enum { memory_order_relaxed = __ATOMIC_RELAXED, memory_order_consume = __ATOMIC_CONSUME, memory_order_acquire = __ATOMIC_ACQUIRE, @@ -52,10 +51,9 @@ typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t; typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t; #define ATOMIC_VAR_INIT(VALUE) (VALUE) -#define atomic_init(PTR, VAL)\ - atomic_store_explicit(PTR, VAL, __ATOMIC_RELAXED) +#define atomic_init(PTR, VAL) atomic_store_explicit(PTR, VAL, __ATOMIC_RELAXED) -#define kill_dependency(y) (y) +#define kill_dependency(y) (y) #if defined(__GNUC__) #define CMPLR_LOCK_FREE(x) GLUE(__GCC_ATOMIC_, x)##_LOCK_FREE @@ -63,16 +61,16 @@ typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t; #define CMPLR_LOCK_FREE(x) GLUE(__CLANG_ATOMIC_, x)##_LOCK_FREE #endif -#define ATOMIC_BOOL_LOCK_FREE CMPLR_LOCK_FREE(BOOL) -#define ATOMIC_CHAR_LOCK_FREE CMPLR_LOCK_FREE(CHAR) +#define ATOMIC_BOOL_LOCK_FREE CMPLR_LOCK_FREE(BOOL) +#define ATOMIC_CHAR_LOCK_FREE CMPLR_LOCK_FREE(CHAR) #define ATOMIC_CHAR16_T_LOCK_FREE CMPLR_LOCK_FREE(CHAR16_T) #define ATOMIC_CHAR32_T_LOCK_FREE CMPLR_LOCK_FREE(CHAR32_T) -#define ATOMIC_WCHAR_T_LOCK_FREE CMPLR_LOCK_FREE(WCHAR32_T) -#define ATOMIC_SHORT_LOCK_FREE CMPLR_LOCK_FREE(SHORT) -#define ATOMIC_INT_LOCK_FREE CMPLR_LOCK_FREE(INT) -#define ATOMIC_LONG_LOCK_FREE CMPLR_LOCK_FREE(LONG) -#define ATOMIC_LLONG_LOCK_FREE CMPLR_LOCK_FREE(LLONG) -#define ATOMIC_POINTER_LOCK_FREE CMPLR_LOCK_FREE(POINTER) +#define ATOMIC_WCHAR_T_LOCK_FREE CMPLR_LOCK_FREE(WCHAR32_T) +#define ATOMIC_SHORT_LOCK_FREE CMPLR_LOCK_FREE(SHORT) +#define ATOMIC_INT_LOCK_FREE CMPLR_LOCK_FREE(INT) +#define ATOMIC_LONG_LOCK_FREE CMPLR_LOCK_FREE(LONG) +#define ATOMIC_LLONG_LOCK_FREE CMPLR_LOCK_FREE(LLONG) +#define ATOMIC_POINTER_LOCK_FREE CMPLR_LOCK_FREE(POINTER) #if defined(__GNUC__) #define C11_ATOMIC(x) GLUE(__atomic_, x) @@ -102,82 +100,79 @@ typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t; #define N_ATOMIC(x) C11_ATOMIC(x) #endif -#define atomic_store_explicit(obj, val, mode)\ - N_ATOMIC(store)(obj, val, mode) +#define atomic_store_explicit(obj, val, mode) N_ATOMIC(store)(obj, val, mode) -#define atomic_store(obj, val)\ +#define atomic_store(obj, val) \ atomic_store_explicit(obj, val, __ATOMIC_SEQ_CST); -#define atomic_load_explicit(obj, mode)\ - N_ATOMIC(load)(obj, mode) +#define atomic_load_explicit(obj, mode) N_ATOMIC(load)(obj, mode) -#define atomic_load(obj)\ - atomic_load_explicit(obj, ATOMIC_SEQ_CST) +#define atomic_load(obj) atomic_load_explicit(obj, ATOMIC_SEQ_CST) -#define atomic_exchange_explicit(obj, val, mode)\ +#define atomic_exchange_explicit(obj, val, mode) \ N_ATOMIC(exchange)(obj, val, mode) -#define atomic_exchange(obj, val)\ +#define atomic_exchange(obj, val) \ atomic_exchange_explicit(obj, val, __ATOMIC_SEQ_CST) #if defined(__GNUC__) -#define atomic_compare_exchange_strong_explicit(obj, val, des, suc, fail)\ +#define atomic_compare_exchange_strong_explicit(obj, val, des, suc, fail) \ N_ATOMIC(compare_exchange)(obj, val, des, 0, suc, fail) #elif defined(__clang__) -#define atomic_compare_exchange_strong_explicit(obj, val, des, suc, fail)\ +#define atomic_compare_exchange_strong_explicit(obj, val, des, suc, fail) \ N_ATOMIC(compare_exchange_strong)(obj, val, des, suc, fail) #endif -#define atomic_compare_exchange_strong(obj, val, des)\ - atomic_compare_exchange_strong_explicit\ - (obj, val, des, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) +#define atomic_compare_exchange_strong(obj, val, des) \ + atomic_compare_exchange_strong_explicit( \ + obj, val, des, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) #if defined(__GNUC__) -#define atomic_compare_exchange_weak_explicit(obj, val, des, suc, fail)\ +#define atomic_compare_exchange_weak_explicit(obj, val, des, suc, fail) \ N_ATOMIC(compare_exchange)(obj, val, des, 1, suc, fail) #elif defined(__clang__) -#define atomic_compare_exchange_weak_explicit(obj, val, des, suc, fail)\ +#define atomic_compare_exchange_weak_explicit(obj, val, des, suc, fail) \ N_ATOMIC(compare_exchange_weak)(obj, val, des, suc, fail) #endif -#define atomic_compare_exchange_weak(obj, val, des)\ - atomic_compare_exchange_weak_explicit\ - (obj, val, des, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) +#define atomic_compare_exchange_weak(obj, val, des) \ + atomic_compare_exchange_weak_explicit(obj, val, des, __ATOMIC_SEQ_CST, \ + __ATOMIC_SEQ_CST) -#define atomic_fetch_add_explicit(obj, val, mode)\ +#define atomic_fetch_add_explicit(obj, val, mode) \ C11_ATOMIC(fetch_add)(obj, val, mode) -#define atomic_fetch_add(obj, val)\ +#define atomic_fetch_add(obj, val) \ atomic_fetch_add_explicit(obj, val, __ATOMIC_SEQ_CST) -#define atomic_fetch_sub_explicit(obj, val, mode)\ +#define atomic_fetch_sub_explicit(obj, val, mode) \ C11_ATOMIC(fetch_sub)(obj, val, mode) -#define atomic_fetch_sub(obj, val)\ +#define atomic_fetch_sub(obj, val) \ atomic_fetch_sub_explicit(obj, val, __ATOMIC_SEQ_CST) -#define atomic_fetch_and_explicit(obj, val, mode)\ +#define atomic_fetch_and_explicit(obj, val, mode) \ C11_ATOMIC(fetch_and)(obj, val, mode) -#define atomic_fetch_and(obj, val)\ +#define atomic_fetch_and(obj, val) \ atomic_fetch_and_explicit(obj, val, __ATOMIC_SEQ_CST) -#define atomic_fetch_xor_explicit(obj, val, mode)\ +#define atomic_fetch_xor_explicit(obj, val, mode) \ C11_ATOMIC(fetch_xor)(obj, val, mode) -#define atomic_fetch_xor(obj, val)\ +#define atomic_fetch_xor(obj, val) \ atomic_fetch_xor_explicit(obj, val, __ATOMIC_SEQ_CST) -#define atomic_fetch_or_explicit(obj, val, mode)\ +#define atomic_fetch_or_explicit(obj, val, mode) \ C11_ATOMIC(fetch_or)(obj, val, mode) -#define atomic_fetch_or(obj, val)\ +#define atomic_fetch_or(obj, val) \ atomic_fetch_or_explicit(obj, val, __ATOMIC_SEQ_CST) -#define atomic_fetch_nand_explicit(obj, val, mode)\ +#define atomic_fetch_nand_explicit(obj, val, mode) \ C11_ATOMIC(fetch_nand)(obj, val, mode) -#define atomic_fetch_nand(obj, val)\ +#define atomic_fetch_nand(obj, val) \ atomic_fetch_nand_explicit(obj, val, __ATOMIC_SEQ_CST) /* skip atomic flags, probably not needed */ diff --git a/include/apos/attrs.h b/include/apos/attrs.h index 0a731cc..094ae54 100644 --- a/include/apos/attrs.h +++ b/include/apos/attrs.h @@ -1,14 +1,14 @@ #ifndef APOS_COMPILER_ATTRIBUTES_H -#define __section(section) __attribute__((__section__(section))) -#define __fmt(x, y) __attribute__((format (__printf__, x, y))) -#define __aligned(a) __attribute__((aligned(a))) -#define __noinline __attribute__((noinline)) -#define __noreturn __attribute__((noreturn)) -#define __packed __attribute__((packed)) -#define __weak __attribute__((weak)) +#define __section(section) __attribute__((__section__(section))) +#define __fmt(x, y) __attribute__((format(__printf__, x, y))) +#define __aligned(a) __attribute__((aligned(a))) +#define __noinline __attribute__((noinline)) +#define __noreturn __attribute__((noreturn)) +#define __packed __attribute__((packed)) +#define __weak __attribute__((weak)) -#define __main __section(".kernel.start") __noinline -#define __init __section(".init.start") __noinline +#define __main __section(".kernel.start") __noinline +#define __init __section(".init.start") __noinline #endif /* APOS_COMPILER_ATTRIBUTES_H */ diff --git a/include/apos/bits.h b/include/apos/bits.h index 1e1106a..cc3cd00 100644 --- a/include/apos/bits.h +++ b/include/apos/bits.h @@ -4,12 +4,12 @@ #include <apos/types.h> #include <apos/builtin.h> -#define __is_set(x, y) ((x) & (y)) -#define __set_bit(x, y) ((x) |= (y)) -#define __clear_bit(x, y) ((x) &= ~(y)) +#define __is_set(x, y) ((x) & (y)) +#define __set_bit(x, y) ((x) |= (y)) +#define __clear_bit(x, y) ((x) &= ~(y)) -#define __is_nset(x, y) (__is_set((x), 1 << (y))) -#define __set_nbit(x, y) (__set_bit((x), 1 << (y))) +#define __is_nset(x, y) (__is_set((x), 1 << (y))) +#define __set_nbit(x, y) (__set_bit((x), 1 << (y))) #define __clear_nbit(x, y) (__clear_bit((x), 1 << (y))) uint16_t __bswap16(uint16_t u); diff --git a/include/apos/debug.h b/include/apos/debug.h index ec591ef..d9d668c 100644 --- a/include/apos/debug.h +++ b/include/apos/debug.h @@ -21,12 +21,13 @@ void setup_dbg(pm_t pt, enum serial_dev dev); struct dbg_info dbg_from_fdt(const void *fdt); -#define COMMON_FORMAT "[%s] %s:%d\n\t" +#define COMMON_FORMAT "[%s] %s:%d\n\t" #define COMMON_ARGS(s) s, __FILE__, __LINE__ -#define bug(fmt, ...) dbg(COMMON_FORMAT fmt, COMMON_ARGS("BUG"), __VA_ARGS__) +#define bug(fmt, ...) dbg(COMMON_FORMAT fmt, COMMON_ARGS("BUG"), __VA_ARGS__) #define warn(fmt, ...) dbg(COMMON_FORMAT fmt, COMMON_ARGS("WARN"), __VA_ARGS__) #define info(fmt, ...) dbg(COMMON_FORMAT fmt, COMMON_ARGS("INFO"), __VA_ARGS__) -#define error(fmt, ...) dbg(COMMON_FORMAT fmt, COMMON_ARGS("ERROR"), __VA_ARGS__) +#define error(fmt, ...) \ + dbg(COMMON_FORMAT fmt, COMMON_ARGS("ERROR"), __VA_ARGS__) #else diff --git a/include/apos/dmem.h b/include/apos/dmem.h index 811f56d..d337e61 100644 --- a/include/apos/dmem.h +++ b/include/apos/dmem.h @@ -13,7 +13,9 @@ stat_t init_devmem(pm_t ram_base, pm_t ram_top); vm_t alloc_devmem(struct tcb *t, pm_t dev_start, size_t bytes, vmflags_t flags); stat_t free_devmem(struct tcb *t, vm_t dev_start); -stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order t); -stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order t); +stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order t); +stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order t); #endif /* APOS_DEV_H */ diff --git a/include/apos/elf.h b/include/apos/elf.h index c0de62e..7d0004a 100644 --- a/include/apos/elf.h +++ b/include/apos/elf.h @@ -5,31 +5,31 @@ #include <apos/types.h> #include <apos/vmem.h> -#define EI_MAGIC 0x7f454c46 +#define EI_MAGIC 0x7f454c46 -#define ELFCLASSNONE 0x0 -#define ELFCLASS32 0x1 -#define ELFCLASS64 0x2 +#define ELFCLASSNONE 0x0 +#define ELFCLASS32 0x1 +#define ELFCLASS64 0x2 -#define ELFDATANONE 0x0 -#define ELFDATA2LSB 0x1 -#define ELFDATA2MSB 0x2 +#define ELFDATANONE 0x0 +#define ELFDATA2LSB 0x1 +#define ELFDATA2MSB 0x2 -#define ELFOSABI_NONE 0x0 -#define ELFOSABI_SYSV 0x0 -#define ELFOSABI_NETBSD 0x2 -#define ELFOSABI_LINUX 0x3 -#define ELFOSABI_HURD 0x4 -#define ELFOSABI_FREEBSD 0x9 -#define ELFOSABI_OPENBSD 0xc +#define ELFOSABI_NONE 0x0 +#define ELFOSABI_SYSV 0x0 +#define ELFOSABI_NETBSD 0x2 +#define ELFOSABI_LINUX 0x3 +#define ELFOSABI_HURD 0x4 +#define ELFOSABI_FREEBSD 0x9 +#define ELFOSABI_OPENBSD 0xc -#define ET_NONE 0x0 -#define ET_REL 0x1 -#define ET_EXEC 0x2 -#define ET_DYN 0x3 -#define ET_CORE 0x4 +#define ET_NONE 0x0 +#define ET_REL 0x1 +#define ET_EXEC 0x2 +#define ET_DYN 0x3 +#define ET_CORE 0x4 -#define EM_RISCV 0xf3 +#define EM_RISCV 0xf3 struct __packed elf_ident { uint32_t ei_magic; @@ -75,22 +75,22 @@ struct __packed elf64_header { uint16_t e_shstrndx; }; -#define PT_NULL 0x0 -#define PT_LOAD 0x1 -#define PT_DYNAMIC 0x2 -#define PT_INTERP 0x3 -#define PT_NOTE 0x4 -#define PT_SHLIB 0x5 -#define PT_PHDR 0x6 -#define PT_TLS 0x7 -#define PT_LOOS 0x60000000 -#define PT_HIOS 0x6fffffff -#define PT_LOPROC 0x70000000 -#define PT_HIPROC 0x7fffffff +#define PT_NULL 0x0 +#define PT_LOAD 0x1 +#define PT_DYNAMIC 0x2 +#define PT_INTERP 0x3 +#define PT_NOTE 0x4 +#define PT_SHLIB 0x5 +#define PT_PHDR 0x6 +#define PT_TLS 0x7 +#define PT_LOOS 0x60000000 +#define PT_HIOS 0x6fffffff +#define PT_LOPROC 0x70000000 +#define PT_HIPROC 0x7fffffff -#define PF_X (1 << 0) -#define PF_W (1 << 1) -#define PF_R (1 << 2) +#define PF_X (1 << 0) +#define PF_W (1 << 1) +#define PF_R (1 << 2) struct __packed program32_header { uint32_t p_type; @@ -114,37 +114,37 @@ struct __packed program64_header { uint64_t p_align; }; -#define SHT_NULL 0x0 -#define SH_PROGBITS 0x1 -#define SHT_SYMTAB 0x2 -#define SHT_STRTAB 0x3 -#define SHT_RELA 0x4 -#define SHT_HASH 0x5 -#define SHT_DYNAMIC 0x6 -#define SHT_NOTE 0x7 -#define SHT_NOBITS 0x8 -#define SHT_REL 0x9 -#define SHT_SHLIB 0x0a -#define SHT_DYNSYM 0x0b -#define SHT_INIT_ARRAY 0x0e -#define SHT_FINI_ARRAY 0x0f -#define SHT_PREINIT_ARRAY 0x10 -#define SHT_GROUP 0x11 -#define SHT_SYMTAB_SHNDX 0x12 -#define SHT_NUM 0x13 +#define SHT_NULL 0x0 +#define SH_PROGBITS 0x1 +#define SHT_SYMTAB 0x2 +#define SHT_STRTAB 0x3 +#define SHT_RELA 0x4 +#define SHT_HASH 0x5 +#define SHT_DYNAMIC 0x6 +#define SHT_NOTE 0x7 +#define SHT_NOBITS 0x8 +#define SHT_REL 0x9 +#define SHT_SHLIB 0x0a +#define SHT_DYNSYM 0x0b +#define SHT_INIT_ARRAY 0x0e +#define SHT_FINI_ARRAY 0x0f +#define SHT_PREINIT_ARRAY 0x10 +#define SHT_GROUP 0x11 +#define SHT_SYMTAB_SHNDX 0x12 +#define SHT_NUM 0x13 -#define SHF_WRITE 0x1 -#define SHF_ALLOC 0x2 -#define SHF_EXECINSTR 0x4 -#define SHF_MERGE 0x10 -#define SHF_STRINGS 0x20 -#define SHF_INFO_LINK 0x40 -#define SHF_LINK_ODER 0x80 -#define SHF_OS_NONCONFORMING 0x100 -#define SHF_GROUP 0x200 -#define SHF_TLS 0x400 -#define SHF_MASKOS 0x0ff00000 -#define SHF_MASKPROC 0xf0000000 +#define SHF_WRITE 0x1 +#define SHF_ALLOC 0x2 +#define SHF_EXECINSTR 0x4 +#define SHF_MERGE 0x10 +#define SHF_STRINGS 0x20 +#define SHF_INFO_LINK 0x40 +#define SHF_LINK_ODER 0x80 +#define SHF_OS_NONCONFORMING 0x100 +#define SHF_GROUP 0x200 +#define SHF_TLS 0x400 +#define SHF_MASKOS 0x0ff00000 +#define SHF_MASKPROC 0xf0000000 struct __packed section32_header { uint32_t sh_name; @@ -172,17 +172,20 @@ struct __packed section64_header { uint64_t s_entsize; }; -#define elf_indent(e) ((struct elf_ident *)e) -#define elf64_header(e) ((struct elf64_header *)e) -#define elf32_header(e) ((struct elf32_header *)e) +#define elf_indent(e) ((struct elf_ident *)e) +#define elf64_header(e) ((struct elf64_header *)e) +#define elf32_header(e) ((struct elf32_header *)e) #define program64_header(p) ((struct program64_header *)p) #define program32_header(p) ((struct program32_header *)p) #define section64_header(s) ((struct section64_header *)s) #define section32_header(s) ((struct section32_header *)s) -#define elf_header_prop(c, e, p) (c == ELFCLASS64 ? elf64_header(e)->p : elf32_header(e)->p) -#define program_header_prop(c, e, p) (c == ELFCLASS64 ? program64_header(e)->p : program32_header(e)->p) -#define section_header_prop(c, e, p) (c == ELFCLASS64 ? section64_header(e)->p : section32_header(e)->p) +#define elf_header_prop(c, e, p) \ + (c == ELFCLASS64 ? elf64_header(e)->p : elf32_header(e)->p) +#define program_header_prop(c, e, p) \ + (c == ELFCLASS64 ? program64_header(e)->p : program32_header(e)->p) +#define section_header_prop(c, e, p) \ + (c == ELFCLASS64 ? section64_header(e)->p : section32_header(e)->p) vm_t load_elf(struct tcb *t, vm_t b); diff --git a/include/apos/mem.h b/include/apos/mem.h index d995b04..7c0fde1 100644 --- a/include/apos/mem.h +++ b/include/apos/mem.h @@ -6,37 +6,39 @@ #define MM_OINFO_WIDTH (sizeof(mm_info_t) * 8) -#define pnum_to_index(pnum, order) (((pnum) >> __o_offset(order)) & (__o_width(order) - 1)) -#define pm_to_index(paddr, order) (pnum_to_index(pm_to_pnum(paddr), (order))) -#define pm_to_pnum(paddr) ((paddr) >> __mm_page_shift) -#define pnum_to_paddr(pnum) ((pnum) << __mm_page_shift) +#define pnum_to_index(pnum, order) \ + (((pnum) >> __o_offset(order)) & (__o_width(order) - 1)) +#define pm_to_index(paddr, order) (pnum_to_index(pm_to_pnum(paddr), (order))) +#define pm_to_pnum(paddr) ((paddr) >> __mm_page_shift) +#define pnum_to_paddr(pnum) ((pnum) << __mm_page_shift) -#define move_forward(var, num) (((var) += (num)) - (num)) +#define move_forward(var, num) (((var) += (num)) - (num)) #define move_paddr(paddr, base, offset) ((((pm_t)(paddr)) - (base)) + (offset)) -#define num_elems(num) (((num) + MM_OINFO_WIDTH - 1) / MM_OINFO_WIDTH) -#define num_indexes(num) ((num) / MM_OINFO_WIDTH) -#define index_elems(num) ((num) / MM_OINFO_WIDTH) -#define state_elems(num) (sizeof(mm_info_t) * (num_elems(num))) -#define next_elems(num) (sizeof(void *) * (num)) -#define max_index(order) (__o_width(order) - 1) +#define num_elems(num) (((num) + MM_OINFO_WIDTH - 1) / MM_OINFO_WIDTH) +#define num_indexes(num) ((num) / MM_OINFO_WIDTH) +#define index_elems(num) ((num) / MM_OINFO_WIDTH) +#define state_elems(num) (sizeof(mm_info_t) * (num_elems(num))) +#define next_elems(num) (sizeof(void *) * (num)) +#define max_index(order) (__o_width(order) - 1) -#define __o_offset(order) (__mm_shifts[order]) -#define __o_width(order) (__mm_widths[order]) -#define __o_size(order) (__mm_sizes[order]) -#define __o_elems(order) (__mm_widths[order] / MM_OINFO_WIDTH) +#define __o_offset(order) (__mm_shifts[order]) +#define __o_width(order) (__mm_widths[order]) +#define __o_size(order) (__mm_sizes[order]) +#define __o_elems(order) (__mm_widths[order] / MM_OINFO_WIDTH) -#define __o_container(idx) ((idx) / MM_OINFO_WIDTH) -#define __o_bit(idx) ((idx) & (MM_OINFO_WIDTH - 1)) +#define __o_container(idx) ((idx) / MM_OINFO_WIDTH) +#define __o_bit(idx) ((idx) & (MM_OINFO_WIDTH - 1)) -#define __va(x) (((char *)(x)) + VM_DMAP - RAM_BASE) -#define __pa(x) (((char *)(x)) + RAM_BASE - VM_DMAP) -#define __page(x) ((x) / BASE_PAGE_SIZE) -#define __addr(x) ((x) * BASE_PAGE_SIZE) -#define __pages(x) (aligned((x), BASE_PAGE_SIZE) ? __page((x)) : __page((x) + BASE_PAGE_SIZE)) +#define __va(x) (((char *)(x)) + VM_DMAP - RAM_BASE) +#define __pa(x) (((char *)(x)) + RAM_BASE - VM_DMAP) +#define __page(x) ((x) / BASE_PAGE_SIZE) +#define __addr(x) ((x)*BASE_PAGE_SIZE) +#define __pages(x) \ + (aligned((x), BASE_PAGE_SIZE) ? __page((x)) : \ + __page((x) + BASE_PAGE_SIZE)) #define __bytes(x) (__addr(x)) - extern size_t __mm_shifts[10]; extern size_t __mm_widths[10]; extern size_t __mm_sizes[10]; @@ -63,6 +65,6 @@ void init_mem(size_t max_order, size_t shifts[10], size_t page_shift); enum mm_mode get_mmode(void *fdt); #define BASE_PAGE_SIZE (__o_size(BASE_PAGE)) -#define BASE_PAGE (MM_O0) +#define BASE_PAGE (MM_O0) #endif /* APOS_MEM_H */ diff --git a/include/apos/mem_regions.h b/include/apos/mem_regions.h index a843141..e2ab64b 100644 --- a/include/apos/mem_regions.h +++ b/include/apos/mem_regions.h @@ -6,8 +6,7 @@ #include <apos/sp_tree.h> #include <arch/vmem.h> -#define mem_container(ptr)\ - container_of(ptr, struct mem_region, sp_n) +#define mem_container(ptr) container_of(ptr, struct mem_region, sp_n) struct mem_region_root { struct sp_root free_regions; @@ -30,18 +29,21 @@ stat_t init_region(struct mem_region_root *r, vm_t start, size_t arena_size); void destroy_region(struct mem_region_root *r); vm_t alloc_region(struct mem_region_root *r, size_t size, size_t *actual_size); -vm_t alloc_fixed_region(struct mem_region_root *r, vm_t start, size_t size, size_t *actual_size); +vm_t alloc_fixed_region(struct mem_region_root *r, vm_t start, size_t size, + size_t *actual_size); stat_t free_region(struct mem_region_root *r, vm_t start); struct mem_region *find_used_region(struct mem_region_root *r, vm_t start); -struct mem_region *find_closest_used_region(struct mem_region_root *r, vm_t start); -struct mem_region *find_free_region(struct mem_region_root *r, size_t size, size_t *align); +struct mem_region *find_closest_used_region(struct mem_region_root *r, + vm_t start); +struct mem_region *find_free_region(struct mem_region_root *r, size_t size, + size_t *align); #define REGION_TRY_AGAIN 1 -typedef stat_t region_callback_t(struct vm_branch *b, - pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order); +typedef stat_t region_callback_t(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order order); vm_t map_fill_region(struct vm_branch *b, region_callback_t *mem_handler, - pm_t offset, vm_t start, size_t bytes, vmflags_t flags); + pm_t offset, vm_t start, size_t bytes, vmflags_t flags); #endif /* APOS_MEM_REGIONS_H */ diff --git a/include/apos/sizes.h b/include/apos/sizes.h index 392e122..1a34d48 100644 --- a/include/apos/sizes.h +++ b/include/apos/sizes.h @@ -3,117 +3,117 @@ #if defined(__ASSEMBLER__) -#define SZ_1 0x000000000001 -#define SZ_2 0x000000000002 -#define SZ_4 0x000000000004 -#define SZ_8 0x000000000008 -#define SZ_16 0x000000000010 -#define SZ_32 0x000000000020 -#define SZ_64 0x000000000040 -#define SZ_128 0x000000000080 -#define SZ_256 0x000000000100 -#define SZ_512 0x000000000200 +#define SZ_1 0x000000000001 +#define SZ_2 0x000000000002 +#define SZ_4 0x000000000004 +#define SZ_8 0x000000000008 +#define SZ_16 0x000000000010 +#define SZ_32 0x000000000020 +#define SZ_64 0x000000000040 +#define SZ_128 0x000000000080 +#define SZ_256 0x000000000100 +#define SZ_512 0x000000000200 -#define SZ_1K 0x000000000400 -#define SZ_2K 0x000000000800 -#define SZ_4K 0x000000001000 -#define SZ_8K 0x000000002000 -#define SZ_16K 0x000000004000 -#define SZ_32K 0x000000008000 -#define SZ_64K 0x000000010000 -#define SZ_128K 0x000000020000 -#define SZ_256K 0x000000040000 -#define SZ_512K 0x000000080000 +#define SZ_1K 0x000000000400 +#define SZ_2K 0x000000000800 +#define SZ_4K 0x000000001000 +#define SZ_8K 0x000000002000 +#define SZ_16K 0x000000004000 +#define SZ_32K 0x000000008000 +#define SZ_64K 0x000000010000 +#define SZ_128K 0x000000020000 +#define SZ_256K 0x000000040000 +#define SZ_512K 0x000000080000 -#define SZ_1M 0x000000100000 -#define SZ_2M 0x000000200000 -#define SZ_4M 0x000000400000 -#define SZ_8M 0x000000800000 -#define SZ_16M 0x000001000000 -#define SZ_32M 0x000002000000 -#define SZ_64M 0x000004000000 -#define SZ_128M 0x000008000000 -#define SZ_256M 0x000010000000 -#define SZ_512M 0x000020000000 +#define SZ_1M 0x000000100000 +#define SZ_2M 0x000000200000 +#define SZ_4M 0x000000400000 +#define SZ_8M 0x000000800000 +#define SZ_16M 0x000001000000 +#define SZ_32M 0x000002000000 +#define SZ_64M 0x000004000000 +#define SZ_128M 0x000008000000 +#define SZ_256M 0x000010000000 +#define SZ_512M 0x000020000000 -#define SZ_1G 0x000040000000 -#define SZ_2G 0x000080000000 -#define SZ_4G 0x000100000000 -#define SZ_8G 0x000200000000 -#define SZ_16G 0x000400000000 -#define SZ_32G 0x000800000000 -#define SZ_64G 0x000400000000 -#define SZ_128G 0x000800000000 -#define SZ_256G 0x001000000000 -#define SZ_512G 0x002000000000 +#define SZ_1G 0x000040000000 +#define SZ_2G 0x000080000000 +#define SZ_4G 0x000100000000 +#define SZ_8G 0x000200000000 +#define SZ_16G 0x000400000000 +#define SZ_32G 0x000800000000 +#define SZ_64G 0x000400000000 +#define SZ_128G 0x000800000000 +#define SZ_256G 0x001000000000 +#define SZ_512G 0x002000000000 -#define SZ_1T 0x004000000000 -#define SZ_2T 0x008000000000 -#define SZ_4T 0x010000000000 -#define SZ_8T 0x020000000000 -#define SZ_16T 0x040000000000 -#define SZ_32T 0x080000000000 -#define SZ_64T 0x100000000000 -#define SZ_128T 0x200000000000 -#define SZ_256T 0x400000000000 -#define SZ_512T 0x800000000000 +#define SZ_1T 0x004000000000 +#define SZ_2T 0x008000000000 +#define SZ_4T 0x010000000000 +#define SZ_8T 0x020000000000 +#define SZ_16T 0x040000000000 +#define SZ_32T 0x080000000000 +#define SZ_64T 0x100000000000 +#define SZ_128T 0x200000000000 +#define SZ_256T 0x400000000000 +#define SZ_512T 0x800000000000 #else -#define SZ_1 0x000000000001UL -#define SZ_2 0x000000000002UL -#define SZ_4 0x000000000004UL -#define SZ_8 0x000000000008UL -#define SZ_16 0x000000000010UL -#define SZ_32 0x000000000020UL -#define SZ_64 0x000000000040UL -#define SZ_128 0x000000000080UL -#define SZ_256 0x000000000100UL -#define SZ_512 0x000000000200UL +#define SZ_1 0x000000000001UL +#define SZ_2 0x000000000002UL +#define SZ_4 0x000000000004UL +#define SZ_8 0x000000000008UL +#define SZ_16 0x000000000010UL +#define SZ_32 0x000000000020UL +#define SZ_64 0x000000000040UL +#define SZ_128 0x000000000080UL +#define SZ_256 0x000000000100UL +#define SZ_512 0x000000000200UL -#define SZ_1K 0x000000000400UL -#define SZ_2K 0x000000000800UL -#define SZ_4K 0x000000001000UL -#define SZ_8K 0x000000002000UL -#define SZ_16K 0x000000004000UL -#define SZ_32K 0x000000008000UL -#define SZ_64K 0x000000010000UL -#define SZ_128K 0x000000020000UL -#define SZ_256K 0x000000040000UL -#define SZ_512K 0x000000080000UL +#define SZ_1K 0x000000000400UL +#define SZ_2K 0x000000000800UL +#define SZ_4K 0x000000001000UL +#define SZ_8K 0x000000002000UL +#define SZ_16K 0x000000004000UL +#define SZ_32K 0x000000008000UL +#define SZ_64K 0x000000010000UL +#define SZ_128K 0x000000020000UL +#define SZ_256K 0x000000040000UL +#define SZ_512K 0x000000080000UL -#define SZ_1M 0x000000100000UL -#define SZ_2M 0x000000200000UL -#define SZ_4M 0x000000400000UL -#define SZ_8M 0x000000800000UL -#define SZ_16M 0x000001000000UL -#define SZ_32M 0x000002000000UL -#define SZ_64M 0x000004000000UL -#define SZ_128M 0x000008000000UL -#define SZ_256M 0x000010000000UL -#define SZ_512M 0x000020000000UL +#define SZ_1M 0x000000100000UL +#define SZ_2M 0x000000200000UL +#define SZ_4M 0x000000400000UL +#define SZ_8M 0x000000800000UL +#define SZ_16M 0x000001000000UL +#define SZ_32M 0x000002000000UL +#define SZ_64M 0x000004000000UL +#define SZ_128M 0x000008000000UL +#define SZ_256M 0x000010000000UL +#define SZ_512M 0x000020000000UL -#define SZ_1G 0x000040000000UL -#define SZ_2G 0x000080000000UL -#define SZ_4G 0x000100000000UL -#define SZ_8G 0x000200000000UL -#define SZ_16G 0x000400000000UL -#define SZ_32G 0x000800000000UL -#define SZ_64G 0x000400000000UL -#define SZ_128G 0x000800000000UL -#define SZ_256G 0x001000000000UL -#define SZ_512G 0x002000000000UL +#define SZ_1G 0x000040000000UL +#define SZ_2G 0x000080000000UL +#define SZ_4G 0x000100000000UL +#define SZ_8G 0x000200000000UL +#define SZ_16G 0x000400000000UL +#define SZ_32G 0x000800000000UL +#define SZ_64G 0x000400000000UL +#define SZ_128G 0x000800000000UL +#define SZ_256G 0x001000000000UL +#define SZ_512G 0x002000000000UL -#define SZ_1T 0x004000000000UL -#define SZ_2T 0x008000000000UL -#define SZ_4T 0x010000000000UL -#define SZ_8T 0x020000000000UL -#define SZ_16T 0x040000000000UL -#define SZ_32T 0x080000000000UL -#define SZ_64T 0x100000000000UL -#define SZ_128T 0x200000000000UL -#define SZ_256T 0x400000000000UL -#define SZ_512T 0x800000000000UL +#define SZ_1T 0x004000000000UL +#define SZ_2T 0x008000000000UL +#define SZ_4T 0x010000000000UL +#define SZ_8T 0x020000000000UL +#define SZ_16T 0x040000000000UL +#define SZ_32T 0x080000000000UL +#define SZ_64T 0x100000000000UL +#define SZ_128T 0x200000000000UL +#define SZ_256T 0x400000000000UL +#define SZ_512T 0x800000000000UL #endif diff --git a/include/apos/sp_tree.h b/include/apos/sp_tree.h index bbf9f9f..1c1525f 100644 --- a/include/apos/sp_tree.h +++ b/include/apos/sp_tree.h @@ -1,13 +1,13 @@ #ifndef SP_TREE_H #define SP_TREE_H -#define sp_root(r) (r.sp_r) -#define sp_left(n) (n->left) -#define sp_right(n) (n->right) -#define sp_rparen(n) (sp_right(n)->parent) -#define sp_lparen(n) (sp_left(n)->parent) -#define sp_paren(n) (n->parent) -#define sp_gparen(n) (n->parent->parent) +#define sp_root(r) (r.sp_r) +#define sp_left(n) (n->left) +#define sp_right(n) (n->right) +#define sp_rparen(n) (sp_right(n)->parent) +#define sp_lparen(n) (sp_left(n)->parent) +#define sp_paren(n) (n->parent) +#define sp_gparen(n) (n->parent->parent) #define sp_has_gparen(n) (sp_paren(n) && sp_gparen(n)) struct sp_node { @@ -21,15 +21,13 @@ struct sp_root { struct sp_node *sp_r; }; -enum sp_dir { - LEFT, RIGHT -}; +enum sp_dir { LEFT, RIGHT }; struct sp_node *sp_first(struct sp_node *n); struct sp_node *sp_last(struct sp_node *n); -void sp_insert(struct sp_node **root, struct sp_node *p, - struct sp_node *n, enum sp_dir d); +void sp_insert(struct sp_node **root, struct sp_node *p, struct sp_node *n, + enum sp_dir d); void sp_remove(struct sp_node **root, struct sp_node *n); diff --git a/include/apos/string.h b/include/apos/string.h index 67cdae8..8a3c737 100644 --- a/include/apos/string.h +++ b/include/apos/string.h @@ -53,79 +53,79 @@ int memcmp(const void *ptr1, const void *ptr2, size_t num); */ #if __has_builtin(__builtin_memcpy) -#define memcpy(dst, src, num) __builtin_memcpy(dst, src, num) +#define memcpy(dst, src, num) __builtin_memcpy(dst, src, num) #endif #if __has_builtin(__builtin_memmove) -#define memmove(dst, src, num) __builtin_memmove(dst, src, num) +#define memmove(dst, src, num) __builtin_memmove(dst, src, num) #endif #if __has_builtin(__builtin_strcpy) -#define strcpy(dst, src) __builtin_strcpy(dst, src) +#define strcpy(dst, src) __builtin_strcpy(dst, src) #endif #if __has_builtin(__builtin_strncpy) -#define strncpy(dst, src, num) __builtin_strncpy(dst, src, num) +#define strncpy(dst, src, num) __builtin_strncpy(dst, src, num) #endif #if __has_builtin(__builtin_strcat) -#define strcat(dst, src) __builtin_strcat(dst, src) +#define strcat(dst, src) __builtin_strcat(dst, src) #endif #if __has_builtin(__builtin_strncat) -#define strncat(dst, src, num) __builtin_strncat(dst, src, num) +#define strncat(dst, src, num) __builtin_strncat(dst, src, num) #endif #if __has_builtin(__builtin_memcmp) -#define memcmp(p1, p2, num) __builtin_memcmp(p1, p2, num) +#define memcmp(p1, p2, num) __builtin_memcmp(p1, p2, num) #endif #if __has_builtin(__builtin_strcmp) -#define strcmp(s1, s2) __builtin_strcmp(s1, s2) +#define strcmp(s1, s2) __builtin_strcmp(s1, s2) #endif #if __has_builtin(__builtin_strncmp) -#define strncmp(s1, s2, num) __builtin_strncmp(s1, s2, num) +#define strncmp(s1, s2, num) __builtin_strncmp(s1, s2, num) #endif #if __has_builtin(__builtin_strncmp) -#define memchr(ptr, val, num) __builtin_memchr(ptr, val, num) +#define memchr(ptr, val, num) __builtin_memchr(ptr, val, num) #endif #if __has_builtin(__builtin_strchr) -#define strchr(str, chr) __builtin_strchr(str, chr) +#define strchr(str, chr) __builtin_strchr(str, chr) #endif #if __has_builtin(__builtin_strcspn) -#define strcspn(s1, s2) __builtin_strcspn(s1, s2) +#define strcspn(s1, s2) __builtin_strcspn(s1, s2) #endif #if __has_builtin(__builtin_strpbrk) -#define strpbrk(s1, s2) __builtin_strpbrk(s1, s2) +#define strpbrk(s1, s2) __builtin_strpbrk(s1, s2) #endif #if __has_builtin(__builtin_strchr) -#define strrchr(s1, s2) __builtin_strrchr(s1, s2) +#define strrchr(s1, s2) __builtin_strrchr(s1, s2) #endif #if __has_builtin(__builtin_strspn) -#define strspn(s1, s2) __builtin_strspn(s1, s2) +#define strspn(s1, s2) __builtin_strspn(s1, s2) #endif #if __has_builtin(__builtin_strstr) -#define strstr(s1, s2) __builtin_strstr(s1, s2) +#define strstr(s1, s2) __builtin_strstr(s1, s2) #endif #if __has_builtin(__builtin_strtok) -#define strtok(s1, s2) __builtin_strtok(s1, s2) +#define strtok(s1, s2) __builtin_strtok(s1, s2) #endif #if __has_builtin(__builtin_memset) -#define memset(p, v, n) __builtin_memset(p, v, n) +#define memset(p, v, n) __builtin_memset(p, v, n) #endif #if __has_builtin(__builtin_strlen) -#define strlen(s) __builtin_strlen(s) +#define strlen(s) __builtin_strlen(s) #endif #endif /* APOS_STRING_H */ diff --git a/include/apos/types.h b/include/apos/types.h index fea71ae..48972da 100644 --- a/include/apos/types.h +++ b/include/apos/types.h @@ -1,179 +1,179 @@ #ifndef APOS_TYPES_H #define APOS_TYPES_H -typedef _Bool bool; -#define true 1 -#define false 0 +typedef _Bool bool; +#define true 1 +#define false 0 -typedef __PTRDIFF_TYPE__ ptrdiff_t; -typedef __WCHAR_TYPE__ wchar_t; -typedef __WINT_TYPE__ wint_t; -typedef __INTMAX_TYPE__ intmax_t; -typedef __UINTMAX_TYPE__ uintmax_t; -typedef __INT8_TYPE__ int8_t; -typedef __INT16_TYPE__ int16_t; -typedef __INT32_TYPE__ int32_t; -typedef __INT64_TYPE__ int64_t; -typedef __UINT8_TYPE__ uint8_t; -typedef __UINT16_TYPE__ uint16_t; -typedef __UINT32_TYPE__ uint32_t; -typedef __UINT64_TYPE__ uint64_t; -typedef __INT_LEAST8_TYPE__ int_least8_t; -typedef __INT_LEAST16_TYPE__ int_least16_t; -typedef __INT_LEAST32_TYPE__ int_least32_t; -typedef __INT_LEAST64_TYPE__ int_least64_t; -typedef __UINT_LEAST8_TYPE__ uint_least8_t; -typedef __UINT_LEAST16_TYPE__ uint_least16_t; -typedef __UINT_LEAST32_TYPE__ uint_least32_t; -typedef __UINT_LEAST64_TYPE__ uint_least64_t; -typedef __INT_FAST8_TYPE__ int_fast8_t; -typedef __INT_FAST16_TYPE__ int_fast16_t; -typedef __INT_FAST32_TYPE__ int_fast32_t; -typedef __INT_FAST64_TYPE__ int_fast64_t; -typedef __UINT_FAST8_TYPE__ uint_fast8_t; -typedef __UINT_FAST16_TYPE__ uint_fast16_t; -typedef __UINT_FAST32_TYPE__ uint_fast32_t; -typedef __UINT_FAST64_TYPE__ uint_fast64_t; -typedef __INTPTR_TYPE__ intptr_t; -typedef __UINTPTR_TYPE__ uintptr_t; +typedef __PTRDIFF_TYPE__ ptrdiff_t; +typedef __WCHAR_TYPE__ wchar_t; +typedef __WINT_TYPE__ wint_t; +typedef __INTMAX_TYPE__ intmax_t; +typedef __UINTMAX_TYPE__ uintmax_t; +typedef __INT8_TYPE__ int8_t; +typedef __INT16_TYPE__ int16_t; +typedef __INT32_TYPE__ int32_t; +typedef __INT64_TYPE__ int64_t; +typedef __UINT8_TYPE__ uint8_t; +typedef __UINT16_TYPE__ uint16_t; +typedef __UINT32_TYPE__ uint32_t; +typedef __UINT64_TYPE__ uint64_t; +typedef __INT_LEAST8_TYPE__ int_least8_t; +typedef __INT_LEAST16_TYPE__ int_least16_t; +typedef __INT_LEAST32_TYPE__ int_least32_t; +typedef __INT_LEAST64_TYPE__ int_least64_t; +typedef __UINT_LEAST8_TYPE__ uint_least8_t; +typedef __UINT_LEAST16_TYPE__ uint_least16_t; +typedef __UINT_LEAST32_TYPE__ uint_least32_t; +typedef __UINT_LEAST64_TYPE__ uint_least64_t; +typedef __INT_FAST8_TYPE__ int_fast8_t; +typedef __INT_FAST16_TYPE__ int_fast16_t; +typedef __INT_FAST32_TYPE__ int_fast32_t; +typedef __INT_FAST64_TYPE__ int_fast64_t; +typedef __UINT_FAST8_TYPE__ uint_fast8_t; +typedef __UINT_FAST16_TYPE__ uint_fast16_t; +typedef __UINT_FAST32_TYPE__ uint_fast32_t; +typedef __UINT_FAST64_TYPE__ uint_fast64_t; +typedef __INTPTR_TYPE__ intptr_t; +typedef __UINTPTR_TYPE__ uintptr_t; /* sort of unconventional, but should be fine */ typedef uintmax_t size_t; typedef intmax_t ssize_t; -#define INT8_C __INT8_C -#define INT16_C __INT16_C -#define INT32_C __INT32_C -#define INT64_C __INT64_C -#define UINT8_C __UINT8_C -#define UINT16_C __UINT16_C -#define UINT32_C __UINT32_C -#define UINT64_C __UINT64_C -#define INTMAX_C __INTMAX_C -#define UINTMAX_C __UINTMAX_C +#define INT8_C __INT8_C +#define INT16_C __INT16_C +#define INT32_C __INT32_C +#define INT64_C __INT64_C +#define UINT8_C __UINT8_C +#define UINT16_C __UINT16_C +#define UINT32_C __UINT32_C +#define UINT64_C __UINT64_C +#define INTMAX_C __INTMAX_C +#define UINTMAX_C __UINTMAX_C -#define CHAR_BIT __CHAR_BIT__ +#define CHAR_BIT __CHAR_BIT__ -#define SCHAR_MAX __SCHAR_MAX__ -#define SCHAR_MIN (-__SCHAR_MAX - 1) -#define UCHAR_MAX (2 * __SCHAR_MAX__ - 1) +#define SCHAR_MAX __SCHAR_MAX__ +#define SCHAR_MIN (-__SCHAR_MAX - 1) +#define UCHAR_MAX (2 * __SCHAR_MAX__ - 1) #if defined(__CHAR_UNSIGNED__) -#define CHAR_MIN 0 -#define CHAR_MAX UCHAR_MAX +#define CHAR_MIN 0 +#define CHAR_MAX UCHAR_MAX #else -#define CHAR_MIN SCHAR_MIN -#define CHAR_MAX SCHAR_MAX +#define CHAR_MIN SCHAR_MIN +#define CHAR_MAX SCHAR_MAX #endif /* probably not necessary? */ -#define MB_LEN_MAX 16 +#define MB_LEN_MAX 16 -#define SHRT_MAX __SHRT_MAX__ -#define SHRT_MIN (-__SHRT_MAX - 1) -#define USHRT_MAX (2 * __SHRT_MAX + 1) +#define SHRT_MAX __SHRT_MAX__ +#define SHRT_MIN (-__SHRT_MAX - 1) +#define USHRT_MAX (2 * __SHRT_MAX + 1) -#define INT_MAX __INT_MAX__ -#define INT_MIN (-__INT_MAX__ - 1) -#define UINT_MAX (2 * __INT_MAX__ + 1) +#define INT_MAX __INT_MAX__ +#define INT_MIN (-__INT_MAX__ - 1) +#define UINT_MAX (2 * __INT_MAX__ + 1) -#define LONG_MAX __LONG__MAX__ -#define LONG_MIN (-__LONG_MAX__ - 1) -#define ULONG_MAX (2 * __INT_MAX__ + 1) +#define LONG_MAX __LONG__MAX__ +#define LONG_MIN (-__LONG_MAX__ - 1) +#define ULONG_MAX (2 * __INT_MAX__ + 1) -#define LLONG_MAX __LONG_LONG_MAX__ -#define LLONG_MIN (-__LONG_LONG_MAX__ - 1) -#define ULLONG_MAX (2 * __LONG_LONG_MAX__ + 1) +#define LLONG_MAX __LONG_LONG_MAX__ +#define LLONG_MIN (-__LONG_LONG_MAX__ - 1) +#define ULLONG_MAX (2 * __LONG_LONG_MAX__ + 1) -#define INT8_MAX __INT8_MAX__ -#define INT8_MIN (-__INT8_MAX__ - 1) -#define UINT8_MAX __UINT8_MAX__ +#define INT8_MAX __INT8_MAX__ +#define INT8_MIN (-__INT8_MAX__ - 1) +#define UINT8_MAX __UINT8_MAX__ -#define INT16_MAX __INT16_MAX__ -#define INT16_MIN (-__INT16_MAX__ - 1) -#define UINT16_MAX __UINT16_MAX__ +#define INT16_MAX __INT16_MAX__ +#define INT16_MIN (-__INT16_MAX__ - 1) +#define UINT16_MAX __UINT16_MAX__ -#define INT32_MAX __INT32_MAX__ -#define INT32_MIN (-__INT32_MAX__ - 1) -#define UINT32_MAX __UINT32_MAX__ +#define INT32_MAX __INT32_MAX__ +#define INT32_MIN (-__INT32_MAX__ - 1) +#define UINT32_MAX __UINT32_MAX__ -#define INT64_MAX __INT64_MAX__ -#define INT64_MIN (-__INT64_MAX__ - 1) -#define UINT64_MAX __UINT64_MAX__ +#define INT64_MAX __INT64_MAX__ +#define INT64_MIN (-__INT64_MAX__ - 1) +#define UINT64_MAX __UINT64_MAX__ -#define INT_LEAST8_MAX __INT_LEAST8_MAX__ -#define INT_LEAST8_MIN (-__INT_LEAST8_MAX__ - 1) -#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__ +#define INT_LEAST8_MAX __INT_LEAST8_MAX__ +#define INT_LEAST8_MIN (-__INT_LEAST8_MAX__ - 1) +#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__ -#define INT_LEAST16_MAX __INT_LEAST16_MAX__ -#define INT_LEAST16_MIN (-__INT_LEAST16_MAX__ - 1) -#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__ +#define INT_LEAST16_MAX __INT_LEAST16_MAX__ +#define INT_LEAST16_MIN (-__INT_LEAST16_MAX__ - 1) +#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__ -#define INT_LEAST32_MAX __INT_LEAST32_MAX__ -#define INT_LEAST32_MIN (-__INT_LEAST32_MAX__ - 1) -#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__ +#define INT_LEAST32_MAX __INT_LEAST32_MAX__ +#define INT_LEAST32_MIN (-__INT_LEAST32_MAX__ - 1) +#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__ -#define INT_LEAST64_MAX __INT_LEAST64_MAX__ -#define INT_LEAST64_MIN (-__INT_LEAST64_MAX__ - 1) -#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__ +#define INT_LEAST64_MAX __INT_LEAST64_MAX__ +#define INT_LEAST64_MIN (-__INT_LEAST64_MAX__ - 1) +#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__ -#define INT_FAST8_MAX __INT_FAST8_MAX__ -#define INT_FAST8_MIN (-__INT_FAST8_MAX__ - 1) -#define UINT_FAST8_MAX __UINT_FAST8_MAX__ +#define INT_FAST8_MAX __INT_FAST8_MAX__ +#define INT_FAST8_MIN (-__INT_FAST8_MAX__ - 1) +#define UINT_FAST8_MAX __UINT_FAST8_MAX__ -#define INT_FAST16_MAX __INT_FAST16_MAX__ -#define INT_FAST16_MIN (-__INT_FAST16_MAX__ - 1) -#define UINT_FAST16_MAX __UINT_FAST16_MAX__ +#define INT_FAST16_MAX __INT_FAST16_MAX__ +#define INT_FAST16_MIN (-__INT_FAST16_MAX__ - 1) +#define UINT_FAST16_MAX __UINT_FAST16_MAX__ -#define INT_FAST32_MAX __INT_FAST32_MAX__ -#define INT_FAST32_MIN (-__INT_FAST32_MAX__ - 1) -#define UINT_FAST32_MAX __UINT_FAST32_MAX__ +#define INT_FAST32_MAX __INT_FAST32_MAX__ +#define INT_FAST32_MIN (-__INT_FAST32_MAX__ - 1) +#define UINT_FAST32_MAX __UINT_FAST32_MAX__ -#define INT_FAST64_MAX __INT_FAST64_MAX__ -#define INT_FAST64_MIN (-__INT_FAST64_MAX__ - 1) -#define UINT_FAST64_MAX __UINT_FAST64_MAX__ +#define INT_FAST64_MAX __INT_FAST64_MAX__ +#define INT_FAST64_MIN (-__INT_FAST64_MAX__ - 1) +#define UINT_FAST64_MAX __UINT_FAST64_MAX__ -#define INTPTR_MAX __INTPTR_MAX__ -#define INTPTR_MIN (-__INTPTR_MAX__ - 1) -#define UINTPTR_MAX __UINTPTR_MAX__ +#define INTPTR_MAX __INTPTR_MAX__ +#define INTPTR_MIN (-__INTPTR_MAX__ - 1) +#define UINTPTR_MAX __UINTPTR_MAX__ -#define INTMAX_MAX __INTMAX_MAX__ -#define INTMAX_MIN (-__INTMAX_MAX__ - 1) -#define UINTMAX_MAX __UINTMAX_MAX__ +#define INTMAX_MAX __INTMAX_MAX__ +#define INTMAX_MIN (-__INTMAX_MAX__ - 1) +#define UINTMAX_MAX __UINTMAX_MAX__ -#define INT8_WIDTH 8 -#define INT16_WIDTH 16 -#define INT32_WIDTH 32 -#define INT64_WIDTH 64 -#define UINT8_WIDTH 8 -#define UINT16_WIDTH 16 -#define UINT32_WIDTH 32 -#define UINT64_WIDTH 64 +#define INT8_WIDTH 8 +#define INT16_WIDTH 16 +#define INT32_WIDTH 32 +#define INT64_WIDTH 64 +#define UINT8_WIDTH 8 +#define UINT16_WIDTH 16 +#define UINT32_WIDTH 32 +#define UINT64_WIDTH 64 -#define INT_FAST8_WIDTH __INT_FAST8_WIDTH__ -#define INT_FAST16_WIDTH __INT_FAST16_WIDTH__ -#define INT_FAST32_WIDTH __INT_FAST32_WIDTH__ -#define INT_FAST64_WIDTH __INT_FAST64_WIDTH__ -#define UINT_FAST8_WIDTH __INT_FAST8_WIDTH__ -#define UINT_FAST16_WIDTH __INT_FAST16_WIDTH__ -#define UINT_FAST32_WIDTH __INT_FAST32_WIDTH__ -#define UINT_FAST64_WIDTH __INT_FAST64_WIDTH__ +#define INT_FAST8_WIDTH __INT_FAST8_WIDTH__ +#define INT_FAST16_WIDTH __INT_FAST16_WIDTH__ +#define INT_FAST32_WIDTH __INT_FAST32_WIDTH__ +#define INT_FAST64_WIDTH __INT_FAST64_WIDTH__ +#define UINT_FAST8_WIDTH __INT_FAST8_WIDTH__ +#define UINT_FAST16_WIDTH __INT_FAST16_WIDTH__ +#define UINT_FAST32_WIDTH __INT_FAST32_WIDTH__ +#define UINT_FAST64_WIDTH __INT_FAST64_WIDTH__ -#define INT_LEAST8_WIDTH __INT_LEAST8_WIDTH__ -#define INT_LEAST16_WIDTH __INT_LEAST16_WIDTH__ -#define INT_LEAST32_WIDTH __INT_LEAST32_WIDTH__ -#define INT_LEAST64_WIDTH __INT_LEAST64_WIDTH__ -#define UINT_LEAST8_WIDTH __INT_LEAST8_WIDTH__ -#define UINT_LEAST16_WIDTH __INT_LEAST16_WIDTH__ -#define UINT_LEAST32_WIDTH __INT_LEAST32_WIDTH__ -#define UINT_LEAST64_WIDTH __INT_LEAST64_WIDTH__ +#define INT_LEAST8_WIDTH __INT_LEAST8_WIDTH__ +#define INT_LEAST16_WIDTH __INT_LEAST16_WIDTH__ +#define INT_LEAST32_WIDTH __INT_LEAST32_WIDTH__ +#define INT_LEAST64_WIDTH __INT_LEAST64_WIDTH__ +#define UINT_LEAST8_WIDTH __INT_LEAST8_WIDTH__ +#define UINT_LEAST16_WIDTH __INT_LEAST16_WIDTH__ +#define UINT_LEAST32_WIDTH __INT_LEAST32_WIDTH__ +#define UINT_LEAST64_WIDTH __INT_LEAST64_WIDTH__ -#define INTPTR_WIDTH __INTPTR_WIDTH__ -#define INTMAX_WIDTH __INTMAX_WIDTH__ -#define UINTPTR_WIDTH __INTPTR_WIDTH__ -#define UINTMAX_WIDTH __INTMAX_WIDTH__ +#define INTPTR_WIDTH __INTPTR_WIDTH__ +#define INTMAX_WIDTH __INTMAX_WIDTH__ +#define UINTPTR_WIDTH __INTPTR_WIDTH__ +#define UINTMAX_WIDTH __INTMAX_WIDTH__ -#define NULL 0 +#define NULL 0 /* some common types used throughout the kernel */ typedef int_fast8_t stat_t; @@ -184,12 +184,12 @@ typedef uint_fast16_t vmflags_t; /* negative error codes are reserved for general usage, positive error codes are * allowed to be function-specific. */ enum { - ERR_EXT = -5, /* already exists */ - ERR_OOMEM = -4, /* out of memory */ - ERR_ADDR = -3, /* illegal address */ - ERR_ALIGN = -2, /* wrong alignment */ - ERR_NF = -1, /* not found */ - OK = 0, /* OK */ + ERR_EXT = -5, /* already exists */ + ERR_OOMEM = -4, /* out of memory */ + ERR_ADDR = -3, /* illegal address */ + ERR_ALIGN = -2, /* wrong alignment */ + ERR_NF = -1, /* not found */ + OK = 0, /* OK */ }; #include <types.h> /* arch-specific type definitions (pm_t/vm_t etc) */ diff --git a/include/apos/utils.h b/include/apos/utils.h index c2cff2c..e060c44 100644 --- a/include/apos/utils.h +++ b/include/apos/utils.h @@ -1,47 +1,49 @@ #ifndef APOS_UTILS_H #define APOS_UTILS_H -#define ABS(a) (a < 0 ? -a : a) +#define ABS(a) (a < 0 ? -a : a) -#define MAX(a, b) ((a) >= (b) ? (a) : (b)) +#define MAX(a, b) ((a) >= (b) ? (a) : (b)) #define MAX3(a, b, c) (MAX(a, b) >= MAX(b, c) ? MAX(a, b) : MAX(b, c)) -#define MAX4(a, b, c, d) (MAX3(a, b, c) >= MAX3(b, c, d) ? MAX3(a, b, c) : MAX3(b, c, d)) +#define MAX4(a, b, c, d) \ + (MAX3(a, b, c) >= MAX3(b, c, d) ? MAX3(a, b, c) : MAX3(b, c, d)) /* etc... */ -#define MIN(a, b) ((a) <= (b) ? (a) : (b)) +#define MIN(a, b) ((a) <= (b) ? (a) : (b)) #define MIN3(a, b, c) (MIN(a, b) <= MIN(b, c) ? MIN(a, b) : MIN(b, c)) -#define MIN4(a, b, c, d) (MIN3(a, b, c) <= MIN3(b, c, d) ? MIN3(a, b, c) : MIN3(b, c, d)) +#define MIN4(a, b, c, d) \ + (MIN3(a, b, c) <= MIN3(b, c, d) ? MIN3(a, b, c) : MIN3(b, c, d)) /* etc... */ #define GLUE2(x, y) x##y -#define GLUE(x, y) GLUE2(x, y) +#define GLUE(x, y) GLUE2(x, y) -#define QUOTE2(x) #x -#define QUOTE(x) QUOTE2(x) +#define QUOTE2(x) #x +#define QUOTE(x) QUOTE2(x) -#define UNUSED(x) ((void)(x)) +#define UNUSED(x) ((void)(x)) #include <apos/builtin.h> #if __has_builtin(__builtin_offsetof) #define offsetof(type, member) __builtin_offsetof(type, member) #else -#define offsetof(type, member) ((size_t)&((type *)0)->member) +#define offsetof(type, member) ((size_t) & ((type *)0)->member) #endif -#define container_of(ptr, type, member) \ - ((type *)((char *)(ptr) - offsetof(type, member))) +#define container_of(ptr, type, member) \ + ((type *)((char *)(ptr)-offsetof(type, member))) #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) #define ALIGNED(x, a) ((x) % a == 0) -#define ptradd(x, y) (((vm_t)(x)) + ((vm_t)(y))) +#define ptradd(x, y) (((vm_t)(x)) + ((vm_t)(y))) #include <apos/types.h> static inline size_t align_up(size_t val, size_t a) { - if(!a) + if (!a) return val; size_t rem = val % a; @@ -54,7 +56,7 @@ static inline size_t align_up(size_t val, size_t a) static inline size_t align_down(size_t val, size_t a) { - if(!a) + if (!a) return val; return val - (val % a); @@ -70,11 +72,11 @@ static inline bool aligned(size_t val, size_t a) static inline size_t asciinum(char c) { - if(c >= '0' && c <= '9') + if (c >= '0' && c <= '9') return c - '0'; - else if(c >= 'A' && c <= 'F') + else if (c >= 'A' && c <= 'F') return c - 'A' + 10; - else if(c >= 'a' && c <= 'f') + else if (c >= 'a' && c <= 'f') return c - 'a' + 10; else return 0; @@ -84,7 +86,7 @@ static inline size_t convnum(const char *c, size_t len, size_t base) { size_t multiplier = 1; size_t sum = 0; - for(size_t i = 0; i < len; ++i){ + for (size_t i = 0; i < len; ++i) { sum += asciinum(c[len - 1 - i]) * multiplier; multiplier *= base; } @@ -92,5 +94,4 @@ static inline size_t convnum(const char *c, size_t len, size_t base) return sum; } - #endif /* APOS_UTILS_H */ diff --git a/include/apos/vmem.h b/include/apos/vmem.h index cbdef2e..571b906 100644 --- a/include/apos/vmem.h +++ b/include/apos/vmem.h @@ -12,16 +12,18 @@ vm_t alloc_fixed_uvmem(struct tcb *r, vm_t start, size_t size, vmflags_t flags); stat_t free_uvmem(struct tcb *r, vm_t a); stat_t init_uvmem(struct tcb *r, vm_t base, vm_t top); -stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order); -stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order); +stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order order); +stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, + vmflags_t flags, enum mm_order order); -#define map_allocd_region(b, start, bytes, flags)\ +#define map_allocd_region(b, start, bytes, flags) \ map_fill_region(b, &alloc_uvmem_wrapper, 0, start, bytes, flags) -#define unmap_freed_region(b, start, bytes)\ +#define unmap_freed_region(b, start, bytes) \ map_fill_region(b, &free_uvmem_wrapper, 0, start, bytes, 0) #define vm_flags(x) ((x) & ~0xff) -#define vp_flags(x) ((x) & 0xff) +#define vp_flags(x) ((x)&0xff) #endif /* APOS_VMEM_H */ diff --git a/include/arch/pmem.h b/include/arch/pmem.h index 1772b36..08a38ed 100644 --- a/include/arch/pmem.h +++ b/include/arch/pmem.h @@ -5,7 +5,7 @@ #include <apos/types.h> #include <pmem.h> -stat_t stat_pmem_conf(void *fdt, size_t *max_order, - size_t *base_bits, size_t bits[NUM_ORDERS]); +stat_t stat_pmem_conf(void *fdt, size_t *max_order, size_t *base_bits, + size_t bits[NUM_ORDERS]); #endif /* APOS_ARCH_PMEM_H */ diff --git a/include/arch/vmem.h b/include/arch/vmem.h index ddb0e54..182af11 100644 --- a/include/arch/vmem.h +++ b/include/arch/vmem.h @@ -3,14 +3,15 @@ #include <vmem.h> -stat_t map_vpage(struct vm_branch *branch, - pm_t paddr, vm_t vaddr, vmflags_t flags, enum mm_order order); +stat_t map_vpage(struct vm_branch *branch, pm_t paddr, vm_t vaddr, + vmflags_t flags, enum mm_order order); stat_t unmap_vpage(struct vm_branch *branch, vm_t vaddr); -stat_t mod_vpage(struct vm_branch *branch, vm_t vaddr, pm_t paddr, vmflags_t flags); +stat_t mod_vpage(struct vm_branch *branch, vm_t vaddr, pm_t paddr, + vmflags_t flags); stat_t stat_vpage(struct vm_branch *branch, vm_t vaddr, pm_t *paddr, - enum mm_order *order, vmflags_t *flags); + enum mm_order *order, vmflags_t *flags); void flush_tlb(); void flush_tlb_all(); diff --git a/include/libfdt.h b/include/libfdt.h index 602cdcb..b59d6e4 100644 --- a/include/libfdt.h +++ b/include/libfdt.h @@ -19,7 +19,8 @@ void __dbg_fdt(const void *fdt, int node_offset, int depth); #define dbg_fdt(...) #endif -#define fdt_load_int_ptr(c, p)\ - ((c) == 2 ? fdt64_to_cpu(*(fdt64_t *)(p)) : fdt32_to_cpu(*(fdt32_t *)(p))) +#define fdt_load_int_ptr(c, p) \ + ((c) == 2 ? fdt64_to_cpu(*(fdt64_t *)(p)) : \ + fdt32_to_cpu(*(fdt32_t *)(p))) #endif diff --git a/lib/fdt_dbg.c b/lib/fdt_dbg.c index aa4f1fe..296a8de 100644 --- a/lib/fdt_dbg.c +++ b/lib/fdt_dbg.c @@ -5,7 +5,7 @@ static void __print_char(char c, int depth) { /* lol, ugly but good enough for now */ - for(int i = 0; i < depth; ++i) + for (int i = 0; i < depth; ++i) dbg("%c", c); } @@ -53,17 +53,17 @@ static int __is_string(const void *data, int len) static void __print_prop_value(const void *data, int len) { - if(len == 0) + if (len == 0) return; dbg(" = "); /* heavily inspired by u-boot's fdt print */ - if(__is_string(data, len)){ + if (__is_string(data, len)) { dbg("\""); int i = 0; - while(i < len){ - if(i > 0) + while (i < len) { + if (i > 0) dbg("\", \""); dbg("%s", (const char *)data); @@ -75,15 +75,17 @@ static void __print_prop_value(const void *data, int len) } else if ((len % 4) == 0) { const int32_t *p = (const int32_t *)data; dbg("<"); - for(int i = 0; i < len / 4; ++i) - dbg("%#08x%s", fdt32_to_cpu(p[i]), i < (len / 4 - 1) ? " " : ""); + for (int i = 0; i < len / 4; ++i) + dbg("%#08x%s", fdt32_to_cpu(p[i]), + i < (len / 4 - 1) ? " " : ""); dbg(">"); } else { const int32_t *p = (const int32_t *)data; dbg("["); - for(int i = 0; i < len / 4; ++i) - dbg("%#02x%s", fdt32_to_cpu(p[i]), i < (len / 4 - 1) ? " " : ""); + for (int i = 0; i < len / 4; ++i) + dbg("%#02x%s", fdt32_to_cpu(p[i]), + i < (len / 4 - 1) ? " " : ""); dbg("]"); } @@ -92,17 +94,18 @@ static void __print_prop_value(const void *data, int len) void __dbg_fdt(const void *fdt, int node_offset, int depth) { int node = 0; - fdt_for_each_subnode(node, fdt, node_offset){ + fdt_for_each_subnode(node, fdt, node_offset) + { __print_char('\t', depth); dbg("%s: {\n", fdt_get_name(fdt, node, 0)); int property = 0; - fdt_for_each_property_offset(property, fdt, node){ - + fdt_for_each_property_offset(property, fdt, node) + { int len; const char *name; const void *data = fdt_getprop_by_offset(fdt, property, - &name, &len); + &name, &len); __print_char('\t', depth + 1); dbg("%s", name); @@ -111,7 +114,6 @@ void __dbg_fdt(const void *fdt, int node_offset, int depth) dbg(";\n"); } - __dbg_fdt(fdt, node, depth + 1); __print_char('\t', depth); |