static void InitObject(NVObject *object) { UINT32 hash; int i; /* Will put an entry into the hash table */ hash=HASH_FIFO(object->id,object->channel); for(i=0;i<HASH_TABLE_COLS;i++) { if(localHash[hash][i].id==0) break; /* Found an empty slot!!! */ /* is object already in cache? */ if(localHash[hash][i].context==object->id) return; } if(i==HASH_TABLE_COLS) { /* There is no room at the inn. Since we can't cope with reloading * context we had better abort here!! */ Info("**** NO ROOM FOR OBJECT %08lx IN HASH TABLE ****\n",object->id); graphicsEngineOk=0; /* Set flag so that we won't use accel */ return; } /* Ok, bung entry in at appropriate place */ localHash[hash][i].id=object->id; localHash[hash][i].context=object->context; (realHash+HASH_ENTRY(hash,i))->id=object->id; (realHash+HASH_ENTRY(hash,i))->context=object->context; }
/** * Insert a fd and associated client into the hash table * @param fd: the file descriptor * @param client: the client */ static inline void hash_insert(int fd, struct client_struct *client) { struct fd_struct *hash_entry = *HASH_ENTRY(fd); struct fd_struct *new_entry = malloc(sizeof(struct fd_struct)); new_entry->fd = fd; client_cpy(&(new_entry->client), client); new_entry->next = hash_entry; *HASH_ENTRY(fd) = new_entry; return; }
/** * Delete a fd and associated client from the hash table * @param fd: the file descriptor * @param client: the client */ static inline void hash_delete(int fd, struct client_struct *client) { struct fd_struct *hash_entry = *HASH_ENTRY(fd); struct fd_struct *next_fd = hash_entry, *prev_fd = next_fd; for (; next_fd; next_fd = next_fd->next) { if (fd == next_fd->fd) break; prev_fd = next_fd; } if (prev_fd == next_fd) *HASH_ENTRY(fd) = next_fd->next; prev_fd->next = next_fd->next; free(next_fd); return; }
/** * Find a matching fd and associated client in the hash table * @param fd: the file descriptor * @param client: the client * @return 1 when a matching is found, 0 otherwise. */ static inline int hash_find(int fd, struct client_struct *client) { struct fd_struct *hash_entry = *HASH_ENTRY(fd); for (; hash_entry; hash_entry = hash_entry->next) if (fd == hash_entry->fd) break; if (!hash_entry) return 0; return is_equal(client, &(hash_entry->client)); }
LOCAL void compress_byte (gif_dest_ptr dinfo, int c) /* Accept and compress one 8-bit byte */ { register hash_int i; register hash_int disp; register hash_entry probe_value; if (dinfo->first_byte) { /* need to initialize waiting_code */ dinfo->waiting_code = c; dinfo->first_byte = FALSE; return; } /* Probe hash table to see if a symbol exists for * waiting_code followed by c. * If so, replace waiting_code by that symbol and return. */ i = ((hash_int) c << (MAX_LZW_BITS-8)) + dinfo->waiting_code; /* i is less than twice 2**MAX_LZW_BITS, therefore less than twice HSIZE */ if (i >= HSIZE) i -= HSIZE; probe_value = HASH_ENTRY(dinfo->waiting_code, c); if (dinfo->hash_code[i] != 0) { /* is first probed slot empty? */ if (dinfo->hash_value[i] == probe_value) { dinfo->waiting_code = dinfo->hash_code[i]; return; } if (i == 0) /* secondary hash (after G. Knott) */ disp = 1; else disp = HSIZE - i; for (;;) { i -= disp; if (i < 0) i += HSIZE; if (dinfo->hash_code[i] == 0) break; /* hit empty slot */ if (dinfo->hash_value[i] == probe_value) { dinfo->waiting_code = dinfo->hash_code[i]; return; } } } /* here when hashtable[i] is an empty slot; desired symbol not in table */ output(dinfo, dinfo->waiting_code); if (dinfo->free_code < LZW_TABLE_SIZE) { dinfo->hash_code[i] = dinfo->free_code++; /* add symbol to hashtable */ dinfo->hash_value[i] = probe_value; } else clear_block(dinfo); dinfo->waiting_code = c; }
static void ClearOutHashTables(void) { int i,j; if(!realHash) realHash=(HashTableEntry *) nvPRAMHTPort; /* Clear out host copy of hash table */ for(i=0;i<HASH_TABLE_ROWS;i++) { for(j=0;j<HASH_TABLE_COLS;j++) { localHash[i][j].id=0; localHash[i][j].context=0; (realHash+HASH_ENTRY(i,j))->id=0; (realHash+HASH_ENTRY(i,j))->context=0; } } /* Clear out hash virtual registers */ for(i=0;i<NV_PRAM_HASH_VIRTUAL__SIZE_1;i++) { PRAM_Write(HASH_VIRTUAL(i),0); } }
bool hash_iter_next(lref_t hash, hash_iter_t * iter, lref_t * key, lref_t * val) { assert(HASHP(hash)); while (*iter < HASH_SIZE(hash)) { if (hash_entry_used_p(HASH_ENTRY(hash, *iter))) { if (key) *key = HASH_ENTRY(hash, *iter)->key; if (val) *val = HASH_ENTRY(hash, *iter)->val; *iter = *iter + 1; return true; } *iter = *iter + 1; } return false; }
#ifdef OST_TRACE_COMPILER_IN_USE #include "imgcommon_src_isp_common_defcor_damperTraces.h" #endif #define HASH_ENTRY(i) i,#i typedef struct { t_defcor_damper_id id; const char* name; t_uint32 addr; } t_defcor_damper_info; static const t_defcor_damper_info KDefCorDamperInfo[DEFCOR_DAMPERS_NUM] = { { HASH_ENTRY(DEFCOR_DUSTER_RC_THRESHOLD), DusterControl_u8_RingCorrectionNormThr_Byte0 }, { HASH_ENTRY(DEFCOR_DUSTER_CC_SIGMA_FACTOR), DusterControl_u8_CenterCorrectionSigmaFactor_Byte0 } }; /* * Constructor */ CDefCorDamper::CDefCorDamper(TraceObject *traceobj):CSharedDamper("DEFCOR", traceobj) { } /* * Actual Constructor */ t_damper_error_code CDefCorDamper::Construct() {
} /* * Local stuff */ #define HASH_ENTRY(id) {id,#id} typedef struct { t_fileio_error id; const char* name; } t_fileio_error_entry; static const t_fileio_error_entry KFioErrorCodesList[] = { HASH_ENTRY(FILE_IO_OK), HASH_ENTRY(FILE_IO_BAD_PARAMETER), HASH_ENTRY(FILE_IO_OPEN_FAILED), HASH_ENTRY(FILE_IO_SEEK_FAILED), HASH_ENTRY(FILE_IO_READ_FAILED), HASH_ENTRY(FILE_IO_WRITE_FAILED) }; #define KFioErrorCodesListSize (sizeof(KFioErrorCodesList)/sizeof(KFioErrorCodesList[0])) /* * Destructor */ METH(~fileio)() { IN0("");
/******************************************************************* lock a hash bucket entry in shared memory for share_mode management ******************************************************************/ static BOOL shm_lock_share_entry(connection_struct *conn, SMB_DEV_T dev, SMB_INO_T inode, int *ptok) { *ptok = 0; /* For purify... */ return shmops->lock_hash_entry(HASH_ENTRY(dev, inode)); }
//----------------------------------------------------------------- // compress a byte void mgLZWEncode::compressByte( BYTE nByte) { if (m_firstByte) { // need to initialize nWaitingCode m_waitingCode = nByte; m_firstByte = FALSE; return; } // Probe hash table to see if a symbol exists for // waiting_code followed by nByte. HashInt i = ((HashInt) nByte << (MAX_LZW_BITS-8)) + m_waitingCode; HashInt nDisp; // i is less than twice 2**MAX_LZW_BITS, therefore less than twice HSIZE if (i >= HASH_SIZE) i -= HASH_SIZE; mgLZWHash lProbeValue = HASH_ENTRY(m_waitingCode, nByte); // is first probed slot not empty? if (m_hashCode[i] != 0) { if (m_hashValue[i] == lProbeValue) { m_waitingCode = m_hashCode[i]; return; } if (i == 0) // secondary hash (after G. Knott) nDisp = 1; else nDisp = HASH_SIZE - i; for (;;) { i -= nDisp; if (i < 0) i += HASH_SIZE; if (m_hashCode[i] == 0) break; // hit empty slot if (m_hashValue[i] == lProbeValue) { m_waitingCode = m_hashCode[i]; return; } } } // here when hashtable[i] is an empty slot; desired symbol not in table writeCode(m_waitingCode); if (m_freeCode < LZW_TABLE_SIZE) { m_hashCode[i] = m_freeCode++; // add symbol to hashtable m_hashValue[i] = lProbeValue; } else clearBlock(); m_waitingCode = nByte; }
/******************************************************************* del the share mode of a file. ********************************************************************/ static void shm_del_share_mode(int token, int fnum) { uint32 dev, inode; int *mode_array; unsigned int hash_entry; share_mode_record *file_scanner_p; share_mode_record *file_prev_p; shm_share_mode_entry *entry_scanner_p; shm_share_mode_entry *entry_prev_p; BOOL found = False; int pid = getpid(); dev = Files[fnum].fd_ptr->dev; inode = Files[fnum].fd_ptr->inode; hash_entry = HASH_ENTRY(dev, inode); mode_array = (int *)shmops->offset2addr(shmops->get_userdef_off()); if(mode_array[hash_entry] == 0) { DEBUG(0,("PANIC ERROR:del_share_mode hash bucket %d empty\n", hash_entry)); return; } file_scanner_p = (share_mode_record *)shmops->offset2addr(mode_array[hash_entry]); file_prev_p = file_scanner_p; while(file_scanner_p) { if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) ) { found = True; break; } else { file_prev_p = file_scanner_p ; file_scanner_p = (share_mode_record *) shmops->offset2addr(file_scanner_p->next_offset); } } if(!found) { DEBUG(0,("ERROR: del_share_mode no entry for dev %d inode %d\n", dev, inode)); return; } if(file_scanner_p->locking_version != LOCKING_VERSION) { DEBUG(0,("ERROR: del_share_modes Deleting old share mode v1 %d dev=%d ino=%d\n", file_scanner_p->locking_version, dev, inode)); if(file_prev_p == file_scanner_p) mode_array[hash_entry] = file_scanner_p->next_offset; else file_prev_p->next_offset = file_scanner_p->next_offset; shmops->shm_free(shmops->addr2offset(file_scanner_p)); return; } found = False; entry_scanner_p = (shm_share_mode_entry*)shmops->offset2addr( file_scanner_p->share_mode_entries); entry_prev_p = entry_scanner_p; while(entry_scanner_p) { if( (pid == entry_scanner_p->e.pid) && (memcmp(&entry_scanner_p->e.time, &Files[fnum].open_time,sizeof(struct timeval)) == 0) ) { found = True; break; } else { entry_prev_p = entry_scanner_p; entry_scanner_p = (shm_share_mode_entry *) shmops->offset2addr(entry_scanner_p->next_share_mode_entry); } } if (found) { /* Decrement the number of entries in the record. */ file_scanner_p->num_share_mode_entries -= 1; DEBUG(2,("del_share_modes Deleting share mode entry dev=%d ino=%d\n", dev, inode)); if(entry_prev_p == entry_scanner_p) /* We are at start of list */ file_scanner_p->share_mode_entries = entry_scanner_p->next_share_mode_entry; else entry_prev_p->next_share_mode_entry = entry_scanner_p->next_share_mode_entry; shmops->shm_free(shmops->addr2offset(entry_scanner_p)); /* PARANOIA TEST */ if(file_scanner_p->num_share_mode_entries < 0) { DEBUG(0,("PANIC ERROR:del_share_mode num_share_mode_entries=%d\n", file_scanner_p->num_share_mode_entries)); return; } /* If we deleted the last share mode entry then remove the share mode record. */ if(file_scanner_p->num_share_mode_entries == 0) { DEBUG(2,("del_share_modes num entries = 0, deleting share_mode dev=%d ino=%d\n", dev, inode)); if(file_prev_p == file_scanner_p) mode_array[hash_entry] = file_scanner_p->next_offset; else file_prev_p->next_offset = file_scanner_p->next_offset; shmops->shm_free(shmops->addr2offset(file_scanner_p)); } } else { DEBUG(0,("ERROR: del_share_modes No share mode dev=%d ino=%d\n", dev, inode)); } }
/******************************************************************* unlock a hash bucket entry in shared memory for share_mode management ******************************************************************/ static BOOL shm_unlock_share_entry(connection_struct *conn, SMB_DEV_T dev, SMB_INO_T inode, int token) { return shmops->unlock_hash_entry(HASH_ENTRY(dev, inode)); }
/******************************************************************* set the share mode of a file. Return False on fail, True on success. ********************************************************************/ static BOOL shm_set_share_mode(int token, int fnum, uint16 port, uint16 op_type) { files_struct *fs_p = &Files[fnum]; int32 dev, inode; int *mode_array; unsigned int hash_entry; share_mode_record *file_scanner_p; share_mode_record *file_prev_p; shm_share_mode_entry *new_entry_p; int new_entry_offset; BOOL found = False; dev = fs_p->fd_ptr->dev; inode = fs_p->fd_ptr->inode; hash_entry = HASH_ENTRY(dev, inode); mode_array = (int *)shmops->offset2addr(shmops->get_userdef_off()); file_scanner_p = (share_mode_record *)shmops->offset2addr(mode_array[hash_entry]); file_prev_p = file_scanner_p; while(file_scanner_p) { if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) ) { found = True; break; } else { file_prev_p = file_scanner_p ; file_scanner_p = (share_mode_record *) shmops->offset2addr(file_scanner_p->next_offset); } } if(!found) { /* We must create a share_mode_record */ share_mode_record *new_mode_p = NULL; int new_offset = shmops->shm_alloc(sizeof(share_mode_record) + strlen(fs_p->name) + 1); if(new_offset == 0) { DEBUG(0,("ERROR:set_share_mode shmops->shm_alloc fail!\n")); return False; } new_mode_p = shmops->offset2addr(new_offset); new_mode_p->locking_version = LOCKING_VERSION; new_mode_p->st_dev = dev; new_mode_p->st_ino = inode; new_mode_p->num_share_mode_entries = 0; new_mode_p->share_mode_entries = 0; pstrcpy(new_mode_p->file_name, fs_p->name); /* Chain onto the start of the hash chain (in the hope we will be used first). */ new_mode_p->next_offset = mode_array[hash_entry]; mode_array[hash_entry] = new_offset; file_scanner_p = new_mode_p; DEBUG(3,("set_share_mode: Created share record for %s (dev %d inode %d)\n", fs_p->name, dev, inode)); } /* Now create the share mode entry */ new_entry_offset = shmops->shm_alloc(sizeof(shm_share_mode_entry)); if(new_entry_offset == 0) { int delete_offset = mode_array[hash_entry]; DEBUG(0,("ERROR:set_share_mode: shmops->shm_alloc fail 1!\n")); /* Unlink the damaged record */ mode_array[hash_entry] = file_scanner_p->next_offset; /* And delete it */ shmops->shm_free( delete_offset ); return False; } new_entry_p = shmops->offset2addr(new_entry_offset); new_entry_p->e.pid = getpid(); new_entry_p->e.share_mode = fs_p->share_mode; new_entry_p->e.op_port = port; new_entry_p->e.op_type = op_type; memcpy( (char *)&new_entry_p->e.time, (char *)&fs_p->open_time, sizeof(struct timeval)); /* Chain onto the share_mode_record */ new_entry_p->next_share_mode_entry = file_scanner_p->share_mode_entries; file_scanner_p->share_mode_entries = new_entry_offset; /* PARANOIA TEST */ if(file_scanner_p->num_share_mode_entries < 0) { DEBUG(0,("PANIC ERROR:set_share_mode num_share_mode_entries=%d\n", file_scanner_p->num_share_mode_entries)); return False; } /* Increment the share_mode_entries counter */ file_scanner_p->num_share_mode_entries += 1; DEBUG(3,("set_share_mode: Created share entry for %s with mode 0x%X pid=%d\n", fs_p->name, fs_p->share_mode, new_entry_p->e.pid)); return(True); }
/******************************************************************* Remove an oplock port and mode entry from a share mode. ********************************************************************/ static BOOL shm_remove_share_oplock(int fnum, int token) { uint32 dev, inode; int *mode_array; unsigned int hash_entry; share_mode_record *file_scanner_p; share_mode_record *file_prev_p; shm_share_mode_entry *entry_scanner_p; shm_share_mode_entry *entry_prev_p; BOOL found = False; int pid = getpid(); dev = Files[fnum].fd_ptr->dev; inode = Files[fnum].fd_ptr->inode; hash_entry = HASH_ENTRY(dev, inode); mode_array = (int *)shmops->offset2addr(shmops->get_userdef_off()); if(mode_array[hash_entry] == 0) { DEBUG(0,("PANIC ERROR:remove_share_oplock: hash bucket %d empty\n", hash_entry)); return False; } file_scanner_p = (share_mode_record *)shmops->offset2addr(mode_array[hash_entry]); file_prev_p = file_scanner_p; while(file_scanner_p) { if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) ) { found = True; break; } else { file_prev_p = file_scanner_p ; file_scanner_p = (share_mode_record *) shmops->offset2addr(file_scanner_p->next_offset); } } if(!found) { DEBUG(0,("ERROR:remove_share_oplock: no entry found for dev=%d ino=%d\n", dev, inode)); return False; } if(file_scanner_p->locking_version != LOCKING_VERSION) { DEBUG(0,("ERROR: remove_share_oplock: Deleting old share mode v1=%d dev=%d ino=%d\n", file_scanner_p->locking_version, dev, inode)); if(file_prev_p == file_scanner_p) mode_array[hash_entry] = file_scanner_p->next_offset; else file_prev_p->next_offset = file_scanner_p->next_offset; shmops->shm_free(shmops->addr2offset(file_scanner_p)); return False; } found = False; entry_scanner_p = (shm_share_mode_entry*)shmops->offset2addr( file_scanner_p->share_mode_entries); entry_prev_p = entry_scanner_p; while(entry_scanner_p) { if( (pid == entry_scanner_p->e.pid) && (entry_scanner_p->e.share_mode == Files[fnum].share_mode) && (memcmp(&entry_scanner_p->e.time, &Files[fnum].open_time,sizeof(struct timeval)) == 0) ) { /* Delete the oplock info. */ entry_scanner_p->e.op_port = 0; entry_scanner_p->e.op_type = 0; found = True; break; } else { entry_prev_p = entry_scanner_p; entry_scanner_p = (shm_share_mode_entry *) shmops->offset2addr(entry_scanner_p->next_share_mode_entry); } } if(!found) { DEBUG(0,("ERROR: remove_share_oplock: No oplock granted. dev=%d ino=%d\n", dev, inode)); return False; } return True; }
static BOOL shm_mod_share_entry(int token, files_struct *fsp, void (*mod_fn)(share_mode_entry *, SMB_DEV_T, SMB_INO_T, void *), void *param) { SMB_DEV_T dev; SMB_INO_T inode; int *mode_array; unsigned int hash_entry; share_mode_record *file_scanner_p; share_mode_record *file_prev_p; shm_share_mode_entry *entry_scanner_p; BOOL found = False; pid_t pid = getpid(); dev = fsp->fd_ptr->dev; inode = fsp->fd_ptr->inode; hash_entry = HASH_ENTRY(dev, inode); mode_array = (int *)shmops->offset2addr(shmops->get_userdef_off()); if(mode_array[hash_entry] == 0) { DEBUG(0,("PANIC ERROR:modify_share_entry: hash bucket %d empty\n", hash_entry)); return False; } file_scanner_p = (share_mode_record *)shmops->offset2addr(mode_array[hash_entry]); file_prev_p = file_scanner_p; while(file_scanner_p) { if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) ) { found = True; break; } else { file_prev_p = file_scanner_p ; file_scanner_p = (share_mode_record *) shmops->offset2addr(file_scanner_p->next_offset); } } if(!found) { DEBUG(0,("ERROR:modify_share_entry: no entry found for dev=%x ino=%.0f\n", (unsigned int)dev, (double)inode)); return False; } if(file_scanner_p->locking_version != LOCKING_VERSION) { DEBUG(0,("ERROR: modify_share_entry: Deleting old share mode v1=%d dev=%x ino=%.0f\n", file_scanner_p->locking_version, (unsigned int)dev, (double)inode)); if(file_prev_p == file_scanner_p) mode_array[hash_entry] = file_scanner_p->next_offset; else file_prev_p->next_offset = file_scanner_p->next_offset; shmops->shm_free(shmops->addr2offset(file_scanner_p)); return False; } found = False; entry_scanner_p = (shm_share_mode_entry*)shmops->offset2addr( file_scanner_p->share_mode_entries); while(entry_scanner_p) { if( (pid == entry_scanner_p->e.pid) && (entry_scanner_p->e.share_mode == fsp->share_mode) && (memcmp(&entry_scanner_p->e.time, &fsp->open_time,sizeof(struct timeval)) == 0) ) { /* * Call the generic function with the given parameter. */ DEBUG(5,("modify_share_entry: Calling generic function to modify entry for dev=%x ino=%.0f\n", (unsigned int)dev, (double)inode)); (*mod_fn)( &entry_scanner_p->e, dev, inode, param); found = True; break; } else { entry_scanner_p = (shm_share_mode_entry *) shmops->offset2addr(entry_scanner_p->next_share_mode_entry); } } if(!found) { DEBUG(0,("ERROR: modify_share_entry: No entry found for dev=%x ino=%.0f\n", (unsigned int)dev, (double)inode)); return False; } return True; }
/******************************************************************* get all share mode entries in shared memory for a dev/inode pair. ********************************************************************/ static int shm_get_share_modes(int cnum, int token, uint32 dev, uint32 inode, share_mode_entry **old_shares) { int *mode_array; unsigned int hash_entry = HASH_ENTRY(dev, inode); share_mode_record *file_scanner_p; share_mode_record *file_prev_p; shm_share_mode_entry *entry_scanner_p; shm_share_mode_entry *entry_prev_p; int num_entries; int num_entries_copied; BOOL found = False; share_mode_entry *share_array = (share_mode_entry *)0; *old_shares = 0; mode_array = (int *)shmops->offset2addr(shmops->get_userdef_off()); if(mode_array[hash_entry] == 0) { DEBUG(5,("get_share_modes hash bucket %d empty\n", hash_entry)); return 0; } file_scanner_p = (share_mode_record *)shmops->offset2addr(mode_array[hash_entry]); file_prev_p = file_scanner_p; while(file_scanner_p) { if( (file_scanner_p->st_dev == dev) && (file_scanner_p->st_ino == inode) ) { found = True; break; } else { file_prev_p = file_scanner_p ; file_scanner_p = (share_mode_record *)shmops->offset2addr( file_scanner_p->next_offset); } } if(!found) { DEBUG(5,("get_share_modes no entry for file dev = %d ino = %d\n", dev, inode)); return (0); } if(file_scanner_p->locking_version != LOCKING_VERSION) { DEBUG(0,("ERROR: get_share_modes Deleting old share mode v1 %d dev=%d ino=%d\n", file_scanner_p->locking_version, dev, inode)); if(file_prev_p == file_scanner_p) mode_array[hash_entry] = file_scanner_p->next_offset; else file_prev_p->next_offset = file_scanner_p->next_offset; shmops->shm_free(shmops->addr2offset(file_scanner_p)); return (0); } /* Allocate the old_shares array */ num_entries = file_scanner_p->num_share_mode_entries; if(num_entries) { *old_shares = share_array = (share_mode_entry *) malloc(num_entries * sizeof(share_mode_entry)); if(*old_shares == 0) { DEBUG(0,("get_share_modes: malloc fail!\n")); return 0; } } num_entries_copied = 0; entry_scanner_p = (shm_share_mode_entry*)shmops->offset2addr( file_scanner_p->share_mode_entries); entry_prev_p = entry_scanner_p; while(entry_scanner_p) { int pid = entry_scanner_p->e.pid; if (pid && !process_exists(pid)) { /* Delete this share mode entry */ shm_share_mode_entry *delete_entry_p = entry_scanner_p; if(entry_prev_p == entry_scanner_p) { /* We are at start of list */ file_scanner_p->share_mode_entries = entry_scanner_p->next_share_mode_entry; entry_scanner_p = (shm_share_mode_entry*)shmops->offset2addr( file_scanner_p->share_mode_entries); entry_prev_p = entry_scanner_p; } else { entry_prev_p->next_share_mode_entry = entry_scanner_p->next_share_mode_entry; entry_scanner_p = (shm_share_mode_entry*) shmops->offset2addr(entry_scanner_p->next_share_mode_entry); } /* Decrement the number of share mode entries on this share mode record */ file_scanner_p->num_share_mode_entries -= 1; /* PARANOIA TEST */ if(file_scanner_p->num_share_mode_entries < 0) { DEBUG(0,("PANIC ERROR: get_share_mode: entries=%d dev=%d ino=%d\n", file_scanner_p->num_share_mode_entries,dev, inode)); return 0; } DEBUG(0,("get_share_modes: process %d no longer exists\n", pid)); shmops->shm_free(shmops->addr2offset(delete_entry_p)); } else { /* This is a valid share mode entry and the process that created it still exists. Copy it into the output array. */ share_array[num_entries_copied].pid = entry_scanner_p->e.pid; share_array[num_entries_copied].share_mode = entry_scanner_p->e.share_mode; share_array[num_entries_copied].op_port = entry_scanner_p->e.op_port; share_array[num_entries_copied].op_type = entry_scanner_p->e.op_type; memcpy(&share_array[num_entries_copied].time, &entry_scanner_p->e.time, sizeof(struct timeval)); num_entries_copied++; DEBUG(5,("get_share_modes Read share mode 0x%X pid=%d\n", entry_scanner_p->e.share_mode, entry_scanner_p->e.pid)); entry_prev_p = entry_scanner_p; entry_scanner_p = (shm_share_mode_entry *) shmops->offset2addr(entry_scanner_p->next_share_mode_entry); } } /* If no valid share mode entries were found then this record shouldn't exist ! */ if(num_entries_copied == 0) { DEBUG(0,("get_share_modes: file with dev %d inode %d empty\n", dev, inode)); if(*old_shares) free((char *)*old_shares); *old_shares = 0; if(file_prev_p == file_scanner_p) mode_array[hash_entry] = file_scanner_p->next_offset; else file_prev_p->next_offset = file_scanner_p->next_offset; shmops->shm_free(shmops->addr2offset(file_scanner_p)); } DEBUG(5,("get_share_modes: file with dev %d inode %d -> %d entries\n", dev, inode, num_entries_copied)); return(num_entries_copied); }
/******************************************************************* unlock a hash bucket entry in shared memory for share_mode management ******************************************************************/ static BOOL shm_unlock_share_entry(int cnum, uint32 dev, uint32 inode, int token) { return shmops->unlock_hash_entry(HASH_ENTRY(dev, inode)); }