struct Frame_Info* ptr_new_frame ;

    uint32 *ptr =NULL;              //1

    uint32 index_of_shared;

    struct Env* myenv = curenv;

    //  allocate_frame(&ptr_new_frame);

    //  1) Allocate a new share object (use allocate_share_object())

         //2

    // RETURN:

    //  a) ShareObjectID (its index in "shares" array) if success

    //  b) E_SHARED_MEM_EXISTS if the shared object already exists

    //  c) E_NO_SHARE if the number of shared objects reaches max "MAX_SHARES"

    //int size1=sizeof(shares)/sizeof(shares[index_of_shared]);

    //int count=100;

​

    if(get_share_object_ID(ownerID, shareName) != E_SHARED_MEM_NOT_EXISTS)

    {

​

        //panic("ERRROR\n");

        return E_SHARED_MEM_EXISTS;

    }

    else

    {

        struct Share *allocatedObject=NULL;

        index_of_shared=  allocate_share_object(&allocatedObject);

        int s= ROUNDUP(size,PAGE_SIZE)/PAGE_SIZE;

        if(size%PAGE_SIZE!=0)

        {

            s++;

        }

        struct Frame_Info* frames_array[s];

        if(index_of_shared!=E_NO_SHARE)

        {

            for(int i=0;i<s;i++)

            {

                ptr_new_frame=NULL;

                //ptr_new_frame =get_frame_info(myenv->env_page_directory,(void *)virtual_address, &ptr);

                int r = allocate_frame(&ptr_new_frame);

                //

                frames_array[i]=ptr_new_frame;

                r = map_frame(myenv->env_page_directory, ptr_new_frame, (void*)virtual_address, PERM_USER|PERM_WRITEABLE);

                virtual_address+=PAGE_SIZE;

            }

            for(int j=0;j<s;j++)

            add_frame_to_storage(allocatedObject->framesStorage,frames_array[j],j);

            //  add_frame_to_storage(allocatedObject[index_of_shared]->framesStorage,ptr_new_frame,index_of_shared);

​

            allocatedObject->ownerID=ownerID;

            allocatedObject->size=size;

            allocatedObject->isWritable= isWritable;

            allocatedObject->references=1;

            for(int i= 0 ;i<64 ; i++)

            {

                allocatedObject->name[i]=shareName[i];

            }

            return index_of_shared;

        }

        else

            return E_NO_SHARE;

​

​

    }

​

​

​

​

​

​

​

    /*//TODO:   [PROJECT 2020 - [6] Shared Variables: Creation] createSharedObject() [Kernel Side]

    // your code is here, remove the panic and write your code

    //panic("createSharedObject() is not implemented yet...!!");

    //cprintf("===>BEFORE: # of free frames = %d\n", calculate_free_frames());

     //The calling environment

    // This function should create the shared object at the given virtual address with the given size

        // and return the ShareObjectID

        // RETURN:

        //  a) ShareObjectID (its index in "shares" array) if success

        //  b) E_SHARED_MEM_EXISTS if the shared object already exists

        //  c) E_NO_SHARE if the number of shared objects reaches max "MAX_SHARES"

​

        // Steps:

​

​

    struct Share *allocatedObject;

    struct Frame_Info* ptr_new_frame ;

    uint32 ptr_page_table;

    uint32 index_of_shared=0;

    allocatedObject->ownerID=ownerID;

    allocatedObject->name=shareName;

    allocatedObject->size=size;

    allocatedObject->empty=0;

    allocatedObject->isWritable= isWritable;

    allocatedObject->references=1;

​

    //  1) Allocate a new share object (use allocate_share_object())

    index_of_shared= allocate_share_object(&allocatedObject);

    if(E_NO_SHARE==index_of_shared)

    {

        panic("this process can't be made.");

    }

    else if( E_SHARED_MEM_EXISTS==index_of_shared)

    {

        return index_of_shared;

    }

    else

    {

        for(int i=virtual_address;i<virtual_address+size;i++)

        {   ptr_new_frame=get_frame_info(myenv->env_page_directory,( void *)virtual_address, &ptr_page_table) ;

            allocate_frame(&ptr_new_frame);

            int r = map_frame(myenv->env_page_directory, ptr_new_frame, (void*)virtual_address, PERM_USER|PERM_PRESENT|PERM_WRITEABLE);

            add_frame_to_storage(shares[index_of_shared]->framesStorage,ptr_new_frame,index_of_shared);

        }

​

​

    }

    //  2) Allocate the required space in the physical memory on a PAGE boundary

    //  3) Map the allocated space on the given "virtual_address" on the current environment "myenv": object OWNER,

    //     with writable permissions

    //  4) Initialize the share object with the following:

    //      a) Set the data members of the object with suitable values (ownerID, name, size, ...)

    //      b) Set references to 1 (as there's 1 user environment that use the object now - OWNER)

    //      c) Store the object's isWritable flag (0:ReadOnly, 1:Writable) for later use by getSharedObject()

    //      d) Add all allocated frames to "frames_storage" of this shared object to keep track of them for later use

    //      (use: add_frame_to_storage())

    //  5)  If succeed: return the ID of the shared object (i.e. its index in the "shares" array)

    //      Else, return suitable error

​

    //panic("This function is not implemented yet\n");

​

    //change this return according to your code

    return 0;*/