// file: shared_memory.cc// author: Marc Bumble// June 1, 2000// Page memory source for shared memory // Copyright (C) 2000 by Marc D. Bumble//  This program is free software; you can redistribute it and/or//  modify it under the terms of the GNU General Public License//  as published by the Free Software Foundation; either version 2//  of the License, or (at your option) any later version.//  This program is distributed in the hope that it will be useful,//  but WITHOUT ANY WARRANTY; without even the implied warranty of//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the//  GNU General Public License for more details.//  You should have received a copy of the GNU General Public License//  along with this program; if not, write to the Free Software//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.#include <shared_memory.h>namespace mem_space {      ////////////////////////////////////////////////////////////////////  //////                             Memory Locks  ////////////////////////////////////////////////////////////////////  //////     //////    Locks are  mutual exclusion locks used  to protect process  //////    from  writing  simultaneously   to  shared  memory.   Each  //////    allocator will  get one semaphore set, and  then with that  //////    semaphore  set, each chunk  will lock  individual elements  //////    with  semaphores from  that  set.  So  each  chunk is  has  //////    access to the semid and the semnum.  A semid is common for  //////    all chunks within a given  allocator, and then each of the  //////    allocator's  chunks will  have its  own  individual semnum  //////    which indicates which semaphore in the semid array.  //////      ////////////////////////////////////////////////////////////////////  // constructor  locks::locks(const mem_space::allocator_key_t& alloc_key,	       const int& proj_id) {    std::string key_file(alloc_key);    // create a file for System V ftok from alloc_key    key_file = std::string("/tmp") + key_file;    // create the empty shm key file, used by ftok()    std::ofstream to(key_file.data());    if (!to) perror("Cannot open key file");    to.close();    // set the semaphore key    key_t mykey = ftok(key_file.c_str(),proj_id);    if (mykey == -1) {      std::clog << "Error:" << __FILE__ << ':' << __LINE__ << ':'		<< " ftok unable to create sem key: " << strerror(errno) 		<< ":  " << key_file << std::endl;      // create an error message to throw with the exception      std::stringstream s;      s << __FILE__ << ':' << __LINE__ << ':'			  << " project id out of range (1 <= proj_id < 128).";      throw (Alloc_Exception::ftok_exception(s.str()));    }    semid = semget(mykey, num_in_array, IPC_CREAT | IPC_EXCL | 0666);//     std::clog << "Status:" << __FILE__ << ':' << __LINE__ << ':'// 	      << " semid: " << semid << "  " << strerror(errno)// 	      << std::endl;    if (semid >= 0) {      // first to create the semaphores      // need to initialize the semaphore set      union semun arg;      struct semid_ds seminfo;      arg.buf = &seminfo;      // set all semaphores to 1 unit avail      // binary locks, ie one process can sieze the lock at a time for each page.      short unsigned sem_vals[num_in_array];       for (int i = 0; i < num_in_array; i++) {	sem_vals[i] = 1;// 	std::clog << "i = " << i << std::endl;      }      arg.array = sem_vals;      if (semctl(semid, 0, SETALL, arg) == -1) {	std::cerr << "File: " << __FILE__ << ':' << __LINE__ << ':'<< "locks::make_lock()";	std::cerr << ": semaphore creation error: " << strerror(errno) << std::endl;	std::stringstream s;	s << __FILE__ << ':' << __LINE__ << ':'	  << " semaphore creation error.";	throw (Alloc_Exception::lock_creation_exception(s.str()));      }    } else {      // The semaphore set already exists      // Do not initialize, just attach and wait until the semaphores are initialized      union semun arg;      struct semid_ds seminfo;      arg.buf = &seminfo;      // wait  at  most for  10  tries to  see  if  the semaphore  get      // initialized by  the process which  created it.  If  within 10      // tests, the process does not get initialized, then fail.      const int& tries = 10;      bool initialized = false;      for (int i = 0; ((i < tries) && (!initialized)); i++) {	// retrieve information on the semaphores	semctl(semid,0,IPC_STAT,arg);	if (arg.buf->sem_otime != 0) {	  initialized = true;	}	sleep(1);      }      if (!initialized) {	std::cerr << "File: " << __FILE__ << ':' << __LINE__ << ':'<< "locks::locks()";	std::cerr << ": semaphore initialization error: " << strerror(errno) << std::endl;	std::stringstream s;	s << __FILE__ << ':' << __LINE__ << ':'	  << " semaphore initialization error.";	throw (Alloc_Exception::lock_creation_exception(s.str()));      }    }  }; // constructor    // destructor  locks::~locks() {    // union semun semctl_arg;    //     for (int i=0; i<num_in_array; i++) {      //      int semctlresult = semctl(semid, i, IPC_RMID, semctl_arg);#ifdef DEBUG    std::cerr << __FILE__ << ":" << __LINE__ << " ~locks()" << std::endl;#endif    int semctlresult = semctl(semid, 0, IPC_RMID);    if ((semctlresult!=0)&&(errno!=EINVAL)) {      std::cerr << __FILE__ << ':' << __LINE__ << " locks::~locks(): ";      std::cerr << " semid: " << semid << "semctlresult: ";      std::cerr << semctlresult << " " << strerror(errno) << std::endl;    }#ifdef SHARED_MEMORY_MESG    std::cerr << "semid: " << semid << " shmctlresult: ";    std::cerr << semctlresult << " " << strerror(errno) << std::endl;#endif    //     }  }; // destructor  // copy consqtructor  locks::locks(const locks& t) {    semid=t.semid;  }; // copy constructor  // assignment operator  locks& locks::operator=(const locks& t) {    if (this != &t) {		// avoid self assignment: t=t      semid=t.semid;    }  // if (this != &t)    return *this;  };  // assignment operator    // equality operator  bool locks::operator==(const locks& t) {    bool flag=false;    if (semid==t.semid) {      flag=true;    }    return flag;  };  // equality operator  // lock print  void locks::print() const {    // print the current semaphore lock values    struct semid_ds seminfo;    union semun arg;    arg.buf = &seminfo;    semctl(semid, 0, IPC_STAT, arg);    //    int nsems = arg.buf->sem_nsems;    unsigned short sem_vals[num_in_array];    arg.array = sem_vals;    semctl(semid, 0, GETALL, arg);    std::cerr << std::endl;    std::cerr << "locks::print()" << std::endl;    std::cerr << "semid    = " << semid << std::endl;    std::cerr << "semval[] = ";    for (int i = 0; i < num_in_array; i++) {      if (!(i%25)) {	std::cerr << std::endl;	std::cerr << "           ";      }      std::cerr << ":" << sem_vals[i];    }    std::cerr << std::endl;  };  //   void locks::lock(int page_num) {    // only set one lock at a time    struct sembuf sem_buf_array[num_in_array];    sem_buf_array[0].sem_num = page_num % num_in_array;    sem_buf_array[0].sem_op = -1;   // take the lock, subtract it away.    sem_buf_array[0].sem_flg = SEM_UNDO;//     std::cerr << __FILE__ << ':' << __LINE__ << ':'<< " locks::lock()";//     std::cerr << "semid: " << semid << std::endl;    int result = semop(semid, sem_buf_array, 1);  // operate on 1 lock at a time    if (result!=0) {      std::stringstream s;      std::cerr << __FILE__ << ':' << __LINE__ << ':'<< " locks::lock()";      std::cerr << ": semaphore lock: " << strerror(errno) << " result: " << result << std::endl;      s << ": semaphore lock errno: " << strerror(errno) << " result: " << result;      s << " lock attempt error." << " semid: " << semid << " page_num: " << page_num;      std::cerr << s .str()<< std::endl;      throw (Alloc_Exception::locking_exception(s.str()));   }	  };  // void lock(int page_num)  //   void locks::unlock(int page_num) {    // only clear one lock at a time    struct sembuf sem_buf_array[1];    sem_buf_array[0].sem_num = page_num % num_in_array;    sem_buf_array[0].sem_op = 1;       // release the lock, add it back    sem_buf_array[0].sem_flg = SEM_UNDO;    int result = semop(semid, sem_buf_array, 1); // operate on 1 lock at a time    if (result!=0) {      std::stringstream s;      std::cerr << __FILE__ << ':' << __LINE__ << ':'<< " locks::unlock()";      std::cerr << ": semaphore unlock: " << strerror(errno) << " result: " << result << std::endl;      s << ": semaphore unlock errno: " << strerror(errno) << " result: " << result;      s << " unlock attempt error." << " semid: " << semid << " page_num: " << page_num;      std::cerr << s .str()<< std::endl;      throw (Alloc_Exception::locking_exception(s.str()));   }	  };  // void unlock(int page_num)      ////////////////////////////////////////////////////////////////////  //////                     class shared_memory_header  ////////////////////////////////////////////////////////////////////  //////     //////    This class is embedded as  the first element in all shared  //////    memory segments.   It contains information  describing the  //////    state of the allocated memory segment.  This class uses no  //////    memory pointers as the  shared memory segment is mapped to  //////    different  addresses  for  different  processes.   So  all  //////    address values must be relative offsets from the beginning  //////    of the allocated segment.  //////      ////////////////////////////////////////////////////////////////////      int shared_memory_header_t::get_page_offset(int page_num) {    // returns the  offset from  the beginning of  the segment  to the    // page  indicated by  page_num.  Just  calculates size  offset in    // terms of  the number of  bytes.  If shm (shared  memory header)    // points to the beginning of the allocated shared memory segment,    // then  the actual  page address  can be  interepreted  using the    // following calls:    //    // int start_page_offset = smh->get_page_offset(start_page4);    // unsigned char* addr = reinterpret_cast<unsigned char*>(smh) +    //                       start_page_offset;    //    // addr  will  then  contain  the correct  memory  address.   This    // approach  is  required because  the  shared  memory segment  is    // memory mapped  to each process  differently, so an  offset from    // the beginning of the segment address is required.    return sizeof(shared_memory_header_t) + bit_vec_size +       page_num*page_size;  }; // get_page_offset()  }  // namespace mem_space