精华内容
下载资源
问答
  • 如何搭建虚拟服务器

    千次阅读 2012-02-07 16:01:14
    供internet 上的用户访问,比如做一个公司的网站,一般情况下,你需要去为自己的网站服务器申请域名和一个公有的ip 地址( public ip),然后还要把自己),的服务器做主机托管或者直接申请虚拟空间用来放置网站内容...

    什么是虚拟服务器。举个例子,如果你想建立一个服务器,供internet 上的用户访问,比如做一个公司的网站,一般情况下,你需要去为自己的网站服务器申请域名和一个公有的ip 地址( public ip),然后还要把自己),的服务器做主机托管或者直接申请虚拟空间用来放置网站内容,不仅申请过程繁琐而且还会产生一定的费用,主要是申请公有ip 地址和做主机托管及虚拟空间的费用较高,如果您的网站本身不会有太多的访问量,那么这笔费用就有些不划算了。针对这种情况,您通过使用路由器的虚拟服务器功能( virtual server)就可以很好的解决这样的矛盾,让建立网)站的过程变得简单便利,而且费用较低。

        这里有一个pat(端口地址转换)的概念需要解释一下,它是路由器能够建立虚拟服(务器的关键。实际上,不同的服务使用不同的端口,比如http 服务使用80 端口、ftp 服务使用21 端口、telnet 服务使用23 端口、smtp 服务使用25 端口、pop3 服务使用110 端口等等,这些端口就像一个个通道,将数据流导向不同的应用。如果路由器wan 端口的公有ip 地址是211.18.106.2,而您在局域网内一台,ip 地址为192.168.2.10 的计算机上建立了http服务且使用端口80,那么通过,pat 就会存在如下对应211.18.106.2 80====〉192.168.2.10 80,说的通俗一点,如果设置了,pat,当,internet 上有对路由器wan 端口ip 地址211.18.106.2)的)80 端口的访问,那么路由器会把这样的服务请求转移到局域网中的相关计算机( 192.168.2.10)上,这也就是虚拟服务器建立的过程。

        所以,如果使用路由器的虚拟服务器功能,那么只需要去申请一个域名,然后和路由器wan 端口的公有ip 地址关联起来即可,大大降低了费用。

        下面以建立一个虚拟的http 服务器(网站)为例,说明路由器中配置虚拟服务器的过程。此例中,路由器wan 端口有一个固定的公有ip 地址211.18.106.2,同时已经在局域,网中一台ip 地址为192.168.2.10 的计算机上建立了http 服务器。

        首先,请访问路由器的配置界面,登陆后点击“ general setup”项,进入路由器的基本配置界面,点击右侧菜单中的“ nat”项,打开二级子菜单,点击其中的“ virtual server”项,进入“虚拟服务器”的配置界面,在右侧的界面中“ private ip”处填写“ 192.168.2.10”,在“ private port”处填写“ 80”,在“type”处选择http 服务的协议类型如“ tcp”,在“public port”处填写“ 80”.

       至此, http 虚拟服务器的配置过程结束,这样internet 上的用户通过访问路由器wan端口的公有ip 地址或与之相关联的域名就可以看到您建立的网站的内容。

    展开全文
  • (2)ioremap,真正用来实现映射,传给它物理地址,它给你映射返回一个虚拟地址 2.如何销毁动态映射 (1)iounmap (2)release_mem_region 注意:映射建立时,是要先申请再映射,然后使用; 使用完后要解除映射时...

    1.如何建立动态映射

    (1)request_mem_region,向内核申请(报告)需要映射的内存资源

    (2)ioremap,真正用来实现映射,传给它物理地址,它给你映射返回一个虚拟地址

    2.如何销毁动态映射

    (1)iounmap

    (2)release_mem_region

    注意:映射建立时,是要先申请再映射,然后使用;  使用完后要解除映射时要先解除映射再释放申请。

     

    转载于:https://www.cnblogs.com/ysx09621/p/10237271.html

    展开全文
  • 探秘malloc是如何申请内存的

    千次阅读 多人点赞 2020-04-28 10:49:26
    我们都清楚malloc申请的内存不是立刻就建立虚拟地址和物理地址的映射的,当int *p = malloc(100*1024)执行这条指令之后,只是在用户空间给程序开辟一段100K左右的大小,然后就返回这段空间的首地址给程序员。...

    今天分析下malloc申请内存时都发生了什么,Let dot it

     

    我们都清楚malloc申请的内存不是立刻就建立虚拟地址和物理地址的映射的,当int *p = malloc(100*1024)执行这条指令之后,只是在用户空间给程序开辟一段100K左右的大小,然后就返回这段空间的首地址给程序员。

    当我们尝试第一次读或者写的时候,就会经过如下步骤的:

    • CPU将此虚拟地址,送到MMU上去
    • MMU会做虚拟到物理地址的转化
    • MMU在操作时发现,此虚拟地址还没有建立物理地址关系,则发生exception
    • CPU则会跳转到exception table,根据出错的类型执行相应的调用函数
    • 此场景就会调用do_translation_fault

     

    我们通过一个简单的malloc例子来分析

    #include <stdio.h>
    #include <malloc.h>
    #include <unistd.h>
     
    int main()
    {
        int i=0;
        char *malloc_data=malloc(1024*200);
        printf("malloc address=0x%lx\n",malloc_data); 
         
        getchar();
     
        for(i=0; i<100; i++)
          malloc_data[i] = i+1;
         
        for(i=0; i<100; i++)
          printf("data=%d\n",malloc_data[i]);
     
        return 0;
    }

    当执行此代码后,会在用户空间分配各个虚拟内存区域

     

    可以看到虚拟地址是属于红色框之类的。有人就会说malloc为啥的不属于heap? 当malloc申请的内存小于128K的时候是属于heap的,自己可以动手实验下。当申请的内存大于128K之后,就会从mmap区域申请内存的。

    当我们尝试写这个虚拟地址的时候,就会发生上面一系列操作,我通过修改内核的代码,当在申请此虚拟地址的时候会发生panic,然后抓到dump。我们通过dump分析

    可以dump的时候此地址和上面例子的地址有差别,不影响我们分析。分析dump我们以dump的地址为准。

    当写malloc申请的内存0x76143BC000的时候,就会发生缺页异常,发生page_fault。 先来看dump的调用栈

    -005|panic()
    -006|do_anonymous_page(inline)
    -006|handle_pte_fault(vmf = 0xFFFFFF80202A3BF0)
    -007|handle_mm_fault(vma = 0xFFFFFFE314E27310, address = 0x00000076143BC000, flags = 0x55)
    -008|do_page_fault(addr = 0x00000076143BC008, esr = 0x92000047, regs = 0xFFFFFF80202A3EC0)
    -009|test_ti_thread_flag(inline)
    -009|do_translation_fault(addr = 0x00000076143BC008, esr = 0x92000047, regs = 0xFFFFFF80202A3EC0)
    -010|do_mem_abort(addr = 0x00000076143BC008, esr = 0x92000047, regs = 0xFFFFFF80202A3EC0)
    -011|el0_da(asm)
     -->|exception
    

    具体为啥会这样,大家可以看下我前面的ARM64异常处理流程,咋们根据调用栈分析代码。

    static int __kprobes do_translation_fault(unsigned long addr,
                          unsigned int esr,
                          struct pt_regs *regs)
    {
        if (addr < TASK_SIZE)
            return do_page_fault(addr, esr, regs);
     
        do_bad_area(addr, esr, regs);
        return 0;
    }

    这里是判断申请的内存属于用户空间还是内核空间,用户空间的大小是TASK_SIZE的。小于此值就是用户空间

    -008|do_page_fault(
        |    addr_=_0x00000076143BC008,         //这就是我们上层传递下来的值,后面会将低12位清空的。
        |    esr = 0x92000047,                  //出错状态寄存器
        |    regs = 0xFFFFFF80202A3EC0)
        |  vma = 0xFFFFFFE314E27310              //这段虚拟内存区域的vma
        |  mm_flags = 0x55
        |  vm_flags = 0x2
        |  major = 0x0
        |  tsk = 0xFFFFFFE300786640              //所属的task_struct
        |  mm = 0xFFFFFFE2EBB33440              //所属的mm_struct
    -009|test_ti_thread_flag(inline)
    -009|do_translation_fault(
        |    addr = 0x00000076143BC008,
        |    esr = 0x92000047,
        |    regs = 0xFFFFFF80202A3EC0)
    -010|do_mem_abort(
        |    addr = 0x00000076143BC008,
        |    esr = 0x92000047,
        |    regs = 0xFFFFFF80202A3EC0)
    -011|el0_da(asm)
     -->|exception
    

    此函数有点长,我们去掉不相关的,保留和我们有用的

    static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,
                       struct pt_regs *regs)
    {
        struct task_struct *tsk;
        struct mm_struct *mm;
        struct siginfo si;
        vm_fault_t fault, major = 0;
        unsigned long vm_flags = VM_READ | VM_WRITE;
        unsigned int mm_flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
        struct vm_area_struct *vma = NULL;
     
        tsk = current;
        mm  = tsk->mm;
     
        /*
         * If we're in an interrupt or have no user context, we must not take
         * the fault.
         */
        if (faulthandler_disabled() || !mm)                    //如果在中断上下文或者是内核线程,就调用no_context处理
            goto no_context;
     
        if (user_mode(regs))                                   //如果是用户模式,则需要设置mm_flags位FAULT_FLAG_USER
            mm_flags |= FAULT_FLAG_USER;
     
        if (is_el0_instruction_abort(esr)) {                   //如果是el0的指令异常,设置flag
            vm_flags = VM_EXEC;
        } else if ((esr & ESR_ELx_WNR) && !(esr & ESR_ELx_CM)) {   //esr寄存器判断是否有写权限之类的
            vm_flags = VM_WRITE;
            mm_flags |= FAULT_FLAG_WRITE;
        }
     
        if (addr < TASK_SIZE && is_el1_permission_fault(esr, regs, addr)) {         //地址属于用户空间,但是出错是在内核空间,也就是内核空间访问了用户空间的地址,报错
            /* regs->orig_addr_limit may be 0 if we entered from EL0 */
            if (regs->orig_addr_limit == KERNEL_DS)
                die_kernel_fault("access to user memory with fs=KERNEL_DS",
                         addr, esr, regs);
     
            if (is_el1_instruction_abort(esr))
                die_kernel_fault("execution of user memory",
                         addr, esr, regs);
     
            if (!search_exception_tables(regs->pc))
                die_kernel_fault("access to user memory outside uaccess routines",
                         addr, esr, regs);
        }
     
        if (!vma || !can_reuse_spf_vma(vma, addr))                   //如果不存在vma,则通过地址找到vma,vma在mm_struct的红黑树中,只需要找此地址属于start和end范围内,就确定了vma
            vma = find_vma(mm, addr);
     
        fault = __do_page_fault(vma, addr, mm_flags, vm_flags, tsk);   //真正处理do_page_fault
        major |= fault & VM_FAULT_MAJOR;                   //major意思是当发现此地址的转化关系在页表中,但是内存就找不到。说明swap到磁盘或者swap分区了。从磁盘将文件swap进来叫major,从swap分区叫minor
     
        if (fault & VM_FAULT_RETRY) {             //是否需要重试retry
            /*
             * If we need to retry but a fatal signal is pending,
             * handle the signal first. We do not need to release
             * the mmap_sem because it would already be released
             * in __lock_page_or_retry in mm/filemap.c.
             */
            if (fatal_signal_pending(current)) {
                if (!user_mode(regs))
                    goto no_context;
                return 0;
            }
     
            /*
             * Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk of
             * starvation.
             */
            if (mm_flags & FAULT_FLAG_ALLOW_RETRY) {
                mm_flags &= ~FAULT_FLAG_ALLOW_RETRY;
                mm_flags |= FAULT_FLAG_TRIED;
     
                /*
                 * Do not try to reuse this vma and fetch it
                 * again since we will release the mmap_sem.
                 */
                vma = NULL;
     
                goto retry;
            }
        }
        up_read(&mm->mmap_sem);
     
    done:
     
        /*
         * Handle the "normal" (no error) case first.
         */
        if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP |
                      VM_FAULT_BADACCESS)))) {
            /*
             * Major/minor page fault accounting is only done
             * once. If we go through a retry, it is extremely
             * likely that the page will be found in page cache at
             * that point.
             */
            if (major) {  //增减major的引用计数
                tsk->maj_flt++;
                perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, regs,
                          addr);
            } else {
                tsk->min_flt++;  //增加minor的引用计数
                perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs,
                          addr);
            }
     
            return 0;
        }
     
        /*
         * If we are in kernel mode at this point, we have no context to
         * handle this fault with.
         */
        if (!user_mode(regs))
            goto no_context;
     
        if (fault & VM_FAULT_OOM) {    //也就是没有内存了
            /*
             * We ran out of memory, call the OOM killer, and return to
             * userspace (which will retry the fault, or kill us if we got
             * oom-killed).
             */
            pagefault_out_of_memory();
            return 0;
        }
     
        clear_siginfo(&si);
        si.si_addr = (void __user *)addr;
     
        if (fault & VM_FAULT_SIGBUS) {
            /*
             * We had some memory, but were unable to successfully fix up
             * this page fault.
             */
            si.si_signo = SIGBUS;
            si.si_code  = BUS_ADRERR;
        } else if (fault & VM_FAULT_HWPOISON_LARGE) {
            unsigned int hindex = VM_FAULT_GET_HINDEX(fault);
     
            si.si_signo = SIGBUS;
            si.si_code  = BUS_MCEERR_AR;
            si.si_addr_lsb  = hstate_index_to_shift(hindex);
        } else if (fault & VM_FAULT_HWPOISON) {
            si.si_signo = SIGBUS;
            si.si_code  = BUS_MCEERR_AR;
            si.si_addr_lsb  = PAGE_SHIFT;
        } else {
            /*
             * Something tried to access memory that isn't in our memory
             * map.
             */
            si.si_signo = SIGSEGV;           //这就是写应用程序,出错后出现的段错误,内核直接回杀死此进程的
            si.si_code  = fault == VM_FAULT_BADACCESS ?
                      SEGV_ACCERR : SEGV_MAPERR;
        }
     
        __do_user_fault(&si, esr);     //信号告知用户层
        return 0;
     
    no_context:
        __do_kernel_fault(addr, esr, regs); //处理内核的部分
        return 0;
    }
    • 此函数主要是确认下当前错误是来自内核还是应用层
    • 当调用__do_page_fault处理完毕后,就会对结果做进一步处理
    • 如果用户空间,则后发信号的方式告知的。
    • 内核的话专门有__do_kernel_fault去处理的
    static int __do_page_fault(struct vm_area_struct *vma, unsigned long addr,
                   unsigned int mm_flags, unsigned long vm_flags,
                   struct task_struct *tsk)
    {
        vm_fault_t fault;
     
        fault = VM_FAULT_BADMAP;
        if (unlikely(!vma))  
            goto out;
        if (unlikely(vma->vm_start > addr))
            goto check_stack;
     
        /*
         * Ok, we have a good vm_area for this memory access, so we can handle
         * it.
         */
    good_area:
        /*
         * Check that the permissions on the VMA allow for the fault which
         * occurred.
         */
        if (!(vma->vm_flags & vm_flags)) {
            fault = VM_FAULT_BADACCESS;
            goto out;
        }
     
        return handle_mm_fault(vma, addr & PAGE_MASK, mm_flags);
     
    check_stack:
        if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
            goto good_area;
    out:
        return fault;
    }
    • 检查vma,以及起始地址
    • 如果起始地址小于addr,则调到check_stack处,此情况针对栈需要扩张的情况
    • 确定vma的权限,比如此vma的权限是没有写的,只读的。如果你去写的话就会报VM_FAULT_BADACCESS错误
    • 则后续会调用handle_mm_fault处理
    vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
            unsigned int flags)
    {
        vm_fault_t ret;
     
        __set_current_state(TASK_RUNNING);
     
        if (!arch_vma_access_permitted(vma, flags & FAULT_FLAG_WRITE,   //权限错误,直接SIGSEGV,段错误
                            flags & FAULT_FLAG_INSTRUCTION,
                            flags & FAULT_FLAG_REMOTE))
            return VM_FAULT_SIGSEGV;
     
        if (unlikely(is_vm_hugetlb_page(vma)))              //巨型页,先不考虑
            ret = hugetlb_fault(vma->vm_mm, vma, address, flags);
        else
            ret = __handle_mm_fault(vma, address, flags);   //正常处理流程
     
        return ret;
    }

    继续分析__handle_mm_fault函数

    static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
            unsigned long address, unsigned int flags)
    {
        struct vm_fault vmf = {                 //根据参数初始化vma_fault结构
            .vma = vma,
            .address = address & PAGE_MASK,
            .flags = flags,
            .pgoff = linear_page_index(vma, address),
            .gfp_mask = __get_fault_gfp_mask(vma),
            .vma_flags = vma->vm_flags,
            .vma_page_prot = vma->vm_page_prot,
        };
        unsigned int dirty = flags & FAULT_FLAG_WRITE;
        struct mm_struct *mm = vma->vm_mm;
        pgd_t *pgd;
        p4d_t *p4d;
        vm_fault_t ret;
     
        pgd = pgd_offset(mm, address);                   //根据虚拟地址和mm_struct结构找到pgd
        p4d = p4d_alloc(mm, pgd, address);               //再接着找到p4d,模拟板目前只有3级页表,也就是没有p4d和pud,这里的话p4d==pgd
        if (!p4d)
            return VM_FAULT_OOM;
     
        vmf.pud = pud_alloc(mm, p4d, address);             
        if (!vmf.pud)
            return VM_FAULT_OOM;
     
        vmf.pmd = pmd_alloc(mm, vmf.pud, address);
        if (!vmf.pmd)
            return VM_FAULT_OOM;
     
        return handle_pte_fault(&vmf);
    }
    • pgd = pgd_offset(mm, address); 根据虚拟地址和mm_struct→pdg基地址就会算出pgd的值
    • p4d = p4d_alloc(mm, pgd, address); 分配p4d,目前没用p4d,#define p4d_alloc(mm, pgd, address) (pgd) 直接返回的是pgd的值
    • vmf.pud = pud_alloc(mm, p4d, address); 
    #define pud_alloc(mm, p4d, address) \
        ((unlikely(pgd_none(*(p4d))) && __pud_alloc(mm, p4d, address)) ? \
            NULL : pud_offset(p4d, address))
    • 是没有p4d的时候,则分配pud,这里因为p4d=pgd,则最后返回的是pgd里面的值
    • vmf.pmd = pmd_alloc(mm, vmf.pud, address);  分配pmd, 会根据pud的值算出pmd的值
    • 处理pte, 也就是说此函数就是算pgd, p4d, pud, pmd,保存到vm_fault结构体中。

    来看下dump中算好的结果。

    -006|handle_pte_fault(
        |    vmf = 0xFFFFFF80202A3BF0 -> (
        |      vma = 0xFFFFFFE314E27310,
        |      flags = 0x55,
        |      gfp_mask = 0x006000C0,
        |      pgoff = 0x076143BC,
        |      address = 0x00000076143BC000,
        |      sequence = 0x2,
        |      orig_pmd = (pmd = 0x0),
        |      pmd = 0xFFFFFFE2E5E5D508 -> (
        |        pmd_=_0xE5E5A003),
        |      pud = 0xFFFFFFE2E5D8BEC0 -> (
        |        pgd = (pgd = 0xE5E5D003)),
        |      orig_pte = (pte = 0x0),
        |      cow_page = 0x0,
        |      memcg = 0x0,
        |      page = 0x0,
        |      pte = 0xFFFFFFE2E5E5ADE0 -> (
        |        pte = 0x00E800026F281F53),
        |      ptl = 0xFFFFFFE3698EC318,
        |      prealloc_pte = 0x0,
        |      vma_flags = 0x00100073,
        |      vma_page_prot = (pgprot = 0x0060000000000FD3)))
    -007|handle_mm_fault(
        |    vma = 0xFFFFFFE314E27310,
        |    address = 0x00000076143BC000,
        |    flags = 0x55)

    转化过程可以参考我的ARM64虚拟地址到物理地址转化文档(手动玩转虚拟地址到物理地址转化

     

    虚拟地址:0x00000076143BC000

    mm_struct→pgd = rd(0xFFFFFFE2E5D8B000) = 0xE5D80003

     

    pdg_index =  (0x00000076143BC000 >> 30) & (0x200 - 1)  = 0x01D8

    pdg = 0xFFFFFFE2E5D8B000+ 0x01D8*8 = 0xFFFFFFE2E5D8BEC0 = rd(0xFFFFFFE2E5D8BEC0 ) = 0xE5E5D003

     

    pmd_index =  (0x00000076143BC000  >> 21) & (0x1FF ) = 0xA1

    pmd = 0xE5E5D003+ 0xA1 * 8 = 0xE5E5D000+ 0xA1 * 8 = 0xE5E5D508 = rd(C:0xE5E5D508) = E5E5A003

     

    通过我们手动计算和dump里面的值是一样的。继续分析代码。

    static vm_fault_t handle_pte_fault(struct vm_fault *vmf)
    {
        pte_t entry;
        int ret = 0;
     
        if (unlikely(pmd_none(*vmf->pmd))) {                         //如果pmd里面的值是0的话,说明了pte是没有的,则将vmf->pte设置为NULL
            vmf->pte = NULL;
        } else if (!(vmf->flags & FAULT_FLAG_SPECULATIVE)) {  
             ....
        }
     
        if (!vmf->pte) {
            if (vma_is_anonymous(vmf->vma))
                return do_anonymous_page(vmf);
            else
                return do_fault(vmf);
        }
     
        if (!pte_present(vmf->orig_pte))
            return do_swap_page(vmf);
     
        entry = vmf->orig_pte;
     
        if (vmf->flags & FAULT_FLAG_WRITE) {
            if (!pte_write(entry))
                return do_wp_page(vmf);
            entry = pte_mkdirty(entry);
        }
        entry = pte_mkyoung(entry);
        if (ptep_set_access_flags(vmf->vma, vmf->address, vmf->pte, entry,
                    vmf->flags & FAULT_FLAG_WRITE)) {
            update_mmu_cache(vmf->vma, vmf->address, vmf->pte);
        } else {
            /*
             * This is needed only for protection faults but the arch code
             * is not yet telling us if this is a protection fault or not.
             * This still avoids useless tlb flushes for .text page faults
             * with threads.
             */
            if (vmf->flags & FAULT_FLAG_WRITE)
                flush_tlb_fix_spurious_fault(vmf->vma, vmf->address);
            if (vmf->flags & FAULT_FLAG_SPECULATIVE)
                ret = VM_FAULT_RETRY;
        }
    unlock:
        pte_unmap_unlock(vmf->pte, vmf->ptl);
        return ret;
    }
    • 如果pmd里面的值是NULL,所以pte不存在,设置pte为NULL
    • 判断此vma是否是匿名页,通过判断vma→vm_ops是否为NULL,

    啥是匿名页:

    • malloc申请的内存
    • stack里申请的内存
    • mmap申请的匿名的内存映射

    以上三种都属于匿名页

    • 很明显我们是malloc申请的内存,就会走到匿名页里面去
    • 如果不是匿名页,那就是有文件背景的页,就是和映射的时候有对应的实体,比如磁盘中的文件
    • pte_present(vmf→orig_pte) 页表存在,页表项不存在,所以swap出去了,需要swap回来
    • 如果页表有写FAULT_FLAG_WRITE权限,则更新脏页flag
    • pte_mkyoung(entry); 意思是页表刚刚访问过,比较young
    • 设置访问权限,更新mmu cache等
    展开全文
  • 不止是单单我们推荐的美国主机商,就算是其他的美国虚拟主机,台湾虚拟主机,香港虚拟主机,甚至中国虚拟主机或任何国家的主机都同样的会面对被封的风险。所以比较实际的做法是给你的网站申请一个专用IP设置...

    如果中国政府要通过IP封网站的话,其实哪家主机商都不能幸免的。不止是单单我们推荐的美国主机商,就算是其他的美国虚拟主机,台湾虚拟主机,香港虚拟主机,甚至中国虚拟主机或任何国家的主机都同样的会面对被封的风险。所以比较实际的做法是给你的网站申请一个专用IP设置(dedicated IP),也称为独立IP。

      你需知道在共享主机(share hosting)里,许多网站共享一个IP地址(如122.10.30.X)。当其中的一些网站因含政治言论,色情资料等等通过IP被屏蔽时,其他网站就会连带被牵累。所以专用IP设置的好处就是确保在共享主机里常见的共享IP问题不会出现。一般的专用IP设置价格是月费美元$2.50,你可以在购买了美国主机服务后再申请专用IP设置。

      如果你不打算订购专用IP设置也不是很大问题,你大可在网站被中国政府屏蔽后要求你的主机商把你的网站迁移到另外一个不受屏蔽的主机服务器上(也就是另一个新的share IP)就可以解决这类问题了。据我们所知,鼎峰网络就有免费提供这类网站迁移的服务。

    转载于:https://www.cnblogs.com/lu5936/p/6149224.html

    展开全文
  • 操作系统的内存管理主要负责内存的分配与回收(malloc 函数:申请内存,free 函数:释放内存),另外地址转换也就是将逻辑地址转换成相应的物理地址等功能也是操作系统内存管理做的事情。###常见的内存管理机制和几种...
  • 1、驱动程序中用MmAllocateContiguousMemory申请内存空间,并把返回的虚拟地址映射成物理地址,把这个物理地址写入PCI器件的寄存器,用于PCI器件向PC机内存传输数据,传输完成后置标志位. 2、应用程序一直用I/O...
  • 因为32位的环境下虚拟地址空间的大小只有4g,而光内核空间就需要1g,所以不可能申请得到,只有在64位的环境下才可以实现,只需要把执行环境改为64x即可 #include <iostream> using namespace std; int main() ...
  • 聊聊虚拟内存

    2021-04-16 13:05:19
    目录前提的内存知识分段和分页页表理解虚拟内存简述一下如何实现缺页中断处理过程 前提的内存知识 内存是什么?说白了就是一长串字节数组。编程的时候难免申请一段内存空间,有了内存空间才能存放数据、存放指令代码...
  • 内存虚拟化 一、地址空间 1.定义 运行的程序看到的系统内存,包含进程的所有...操作系统为每一个程序提供的虚拟内存都是从0k开始,但是物理位置却并不是这样,如何高效地为不同的地址空间分配真正的物理地址 二、地址
  • 虚拟主机配置在apache上算比较麻烦的部分,因为它不光只是涉及到apache服务器的问题,还需要相关的dns来支持 首先,要通过多个url通达一台主机,那样的话就需要dns服务器上对你的ip地址注册多个url隐射,也就是申请...
  • 手把手教你如何让自己的电脑成为小型服务器,让外网的电脑可以访问你的网址(项目)   第一步:先去下载“花生壳”软件,软件下载地址:http://www.oray.com/peanuthull/download.php 第二步:安装,并注册个...
  • 文件操作是应用程序最为基本的功能之一,在Linux下,采用申请虚拟内存的方法,可以申请到2g以上的内存,但是能操过3g-程序本身所占内存大小。在Windows2000中,一般能申请1g以上的内存,不能超过2g-程序本身所占内存...
  • VM虚拟机 Linux网络配置(Center os 6.8)。

    千次阅读 2018-08-28 11:01:43
    因为个人原因,VM进行了重装,使用了备份的Linux系统,这个时候发现,ip地址变成了动态申请,并且这个时候无法用eth0联网了,这涉及最常见的两个最常见的问题 1手动设置ip地址 2和备份后的虚拟机如何启用etho0. ...
  • 任务一:先锋公司从网络服务提供商申请了一个域名xianfeng.com。现需要搭建本公司内部web服务器提供网站服务,要求如下: 1、网站服务器域名为... 4、服务器IP地址可以自行设定 (一)、确认系统中具备...
  • 因此申请了一个短邮箱域名(如h.com)。...首先要确保每个邮箱地址的前缀必须和老邮箱地址的前缀是一样的。其次要在Postfix中进行如下设置。在/etc/postfix/main.cf中: mydestination = 后面加入...
  • 任务一:先锋公司从网络服务提供商申请了一个域名xianfeng.com。现需要搭建本公司内部web服务器提供网站服务,要求如下: 1、网站服务器域名为www.xianfeng.com 2、... 4、服务器IP地址可以自行设定 (一)、确认...
  • 腾讯云免费SSL证书基本上可以满足我们小网站的需求,大家可以参考这篇:腾讯云免费SSL证书申请地址 申请到证书即可。但是问 题来了,腾讯云免费SSL证书生成的SSL证书只提供,KEY+CRT,缺少证书签名请求CSR,应该...
  • 手把手教你如何让自己的电脑成为小型服务器,让外网的电脑可以访问你的网址(项目) 第一步:先去下载“花生壳”软件,软件下载地址:http://www.oray.com/peanuthull/download.php 第二步:安装,并...
  • 如何搭建自己的网站

    2017-07-04 19:10:30
    1.申请域名,去万网或者新网申请域名。49元 2.购买服务器。买香港里的,一个月九块钱左右。去淘宝,香港免备案支持linux + php + Mysql. 3.进入域名的管理界面。假如在万网购买,那就登录万网的页面,登录会员。...
  • 阿里用户可以申请【阿里共享虚拟主机普惠版6元/年】,虽然配置和空间不高,但也可以做个小站点的。当不满足当前配置的时候,随时可以进行升级,所以拿来练手还是比较合适的。 2、WordPress文件下载地址 ...
  • 申请弹性公网IP时请将“ip_address”的值设置为您想找回或指定的IP地址。详情请参见《虚拟私有云API参考》。 说明: 如果该地址已被分配给其他用户则无法申请成功。 管理控制台不支持找回或创建指定的弹性公网...
  • 我们单位是64位开发平台,自己定义一套内存管理机制,如果用自定义的内存申请函数,如aaa_malloc,所申请的空间在所有进程中的物理地址和虚拟地址都是一样的。 现在要移植一个开源软件,这个软件会在多核设备上运行...
  • 免费的建站程序很多,下面听哥给你亮出来,建站一般来说分主要有这四步:申请域名、申请虚拟主机、制作网页,网站宣传推广! 教学地址:云上建站快速入门 一域名注册选个好的域名是一个成功网站的开...
  • API接口申请地址:http://idc.125800.vip/(如何查看API,点击资料即可查看API) PHP必须环境或启用的系统函数: curl gd iconv mbstring mcrypt mysqli mysqlnd PDO pdo_mysql openssl fileinfo 安装说明...
  • 一、申请域名 域名,简单来说就是网站的网址,展示在浏览器顶部地址栏处。域名选择时,一定要起与企业品牌名称、产品相关联的,比如,百度域名为baidu.com;而且要选择好记的,不能起得太长。由于域名的唯一性,可能...
  • 我们在申请海外主机,尤其是一些免费主机产品的时候是不是很多时候不让我们的地址使用?麦子和大家一样经常的被鄙视。但是,要相信我们的智慧以及网络资源的丰富性。作为IP地址我们可以更换,账户信息可以模拟海外...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 157
精华内容 62
关键字:

如何申请虚拟地址