int mutex_lock(mutex_t* mtx) { if(unlikely(!mtx)) return E_ERR; if(mtx->owner != sys_getpid()) { #if CONFIG_IPC_DEBUG if(likely(mtx->name)) kprintf(LOG, "[%d] %s: LOCKED from %d\n", mtx->owner, mtx->name, sys_getpid()); #endif spinlock_lock(&mtx->lock); mtx->owner = sys_getpid(); mtx->recursion = 0; } else if(mtx->kind == MTX_KIND_ERRORCHECK) { #if CONFIG_IPC_DEBUG if(likely(mtx->name)) kprintf(ERROR, "[%d] %s: DEADLOCK from %d\n", mtx->owner, mtx->name, sys_getpid()); #endif return E_ERR; } if(mtx->kind == MTX_KIND_RECURSIVE) mtx->recursion += 1; return E_OK; }
static int restore_signals(siginfo_t *ptr, int nr, bool group) { int ret, i; k_rtsigset_t to_block; ksigfillset(&to_block); ret = sys_sigprocmask(SIG_SETMASK, &to_block, NULL, sizeof(k_rtsigset_t)); if (ret) { pr_err("Unable to block signals %d", ret); return -1; } for (i = 0; i < nr; i++) { siginfo_t *info = ptr + i; pr_info("Restore signal %d group %d\n", info->si_signo, group); if (group) ret = sys_rt_sigqueueinfo(sys_getpid(), info->si_signo, info); else ret = sys_rt_tgsigqueueinfo(sys_getpid(), sys_gettid(), info->si_signo, info); if (ret) { pr_err("Unable to send siginfo %d %x with code %d\n", info->si_signo, info->si_code, ret); return -1;; } } return 0; }
static void sigchld_handler(int signal, siginfo_t *siginfo, void *data) { char *r; if (futex_get(&task_entries->start) == CR_STATE_RESTORE_SIGCHLD) { pr_debug("%ld: Collect a zombie with (pid %d, %d)\n", sys_getpid(), siginfo->si_pid, siginfo->si_pid); futex_dec_and_wake(&task_entries->nr_in_progress); futex_dec_and_wake(&zombies_inprogress); task_entries->nr_threads--; task_entries->nr_tasks--; mutex_unlock(&task_entries->zombie_lock); return; } if (siginfo->si_code & CLD_EXITED) r = " exited, status="; else if (siginfo->si_code & CLD_KILLED) r = " killed by signal "; else r = "disappeared with "; pr_info("Task %d %s %d\n", siginfo->si_pid, r, siginfo->si_status); futex_abort_and_wake(&task_entries->nr_in_progress); /* sa_restorer may be unmaped, so we can't go back to userspace*/ sys_kill(sys_getpid(), SIGSTOP); sys_exit_group(1); }
void process_main(void) { while (1) { if (rand() % ALLOC_SLOWDOWN == 0) { if (sys_fork() == 0) { break; } } else { sys_yield(); } } pid_t p = sys_getpid(); srand(p); // The heap starts on the page right after the 'end' symbol, // whose address is the first address not allocated to process code // or data. heap_top = ROUNDUP((uint8_t*) end, PAGESIZE); // The bottom of the stack is the first address on the current // stack page (this process never needs more than one stack page). stack_bottom = ROUNDDOWN((uint8_t*) read_rsp() - 1, PAGESIZE); // Allocate heap pages until (1) hit the stack (out of address space) // or (2) allocation fails (out of physical memory). while (1) { int x = rand() % (8 * ALLOC_SLOWDOWN); if (x < 8 * p) { if (heap_top == stack_bottom || sys_page_alloc(heap_top) < 0) { break; } *heap_top = p; /* check we have write access to new page */ heap_top += PAGESIZE; if (console[CPOS(24, 0)]) { /* clear "Out of physical memory" msg */ console_printf(CPOS(24, 0), 0, "\n"); } } else if (x == 8 * p) { if (sys_fork() == 0) { p = sys_getpid(); } } else if (x == 8 * p + 1) { sys_exit(); } else { sys_yield(); } } // After running out of memory while (1) { if (rand() % (2 * ALLOC_SLOWDOWN) == 0) { sys_exit(); } else { sys_yield(); } } }
void xmutex_unlock(struct xmutex * lock, sigset_t sigset) { TRACE(MUTEX, "thread %d:%d is unlocking %p\n", sys_getpid(), sys_gettid(), lock); /* atomic_dec(&lock->val) != 1 */ if (!atomic_dec_and_test(&lock->val)) { atomic_set(&lock->val, 0); futex_wake(&lock->val, 1); } restore_signals(sigset); TRACE(MUTEX, "thread %d:%d unlocked %p\n", sys_getpid(), sys_gettid(), lock); }
void sys__exit(int exitcode) { pid_t pid = sys_getpid(); struct processhandler *ph; ph = pidmanager_get(pidmgr, pid); //kprintf("HERE1\n"); assert(ph != NULL); //kprintf("HERE2\n"); lock_acquire(ph->ph_exitlock); //kprintf("exiting here on this pid %d with exitcode %d\n", pid, exitcode); ph->ph_status = PH_EXITED; ph->ph_exitcode = exitcode; // wakes up all threads sleeping on the exit lock cv_signal(ph->ph_exitcv, ph->ph_exitlock); lock_release(ph->ph_exitlock); // exit the thread //int s = splhigh(); //kprintf ("exiting: %d\n", curthread->t_pid); //splx(s); thread_exit(); return; }
static void tcpip_init_done(void* arg) { current_task->name = "[tcpipd]"; current_task->description = "TCP/IP Stack daemon"; current_task->priority = TASK_PRIO_MIN; #if DEBUG kprintf(LOG "[%d] tcpip: initialized in %d MS\n", sys_getpid(), (uintptr_t) (timer_getms() - (uintptr_t) arg)); #else (void) arg; #endif struct netif* lo = netif_find("lo0"); if(likely(lo)) { netif_set_up(lo); netif_set_default(lo); } else kprintf(WARN "netif: Loopback interface not found\n"); ip_addr_t dns[2]; IP4_ADDR(&dns[0], 8, 8, 8, 8); IP4_ADDR(&dns[1], 8, 8, 4, 4); dns_setserver(0, &dns[0]); dns_setserver(1, &dns[1]); }
static BOOL retrieve_all_messages(char **msgs_buf, size_t *total_len) { TDB_DATA kbuf; TDB_DATA dbuf; TDB_DATA null_dbuf; ZERO_STRUCT(null_dbuf); *msgs_buf = NULL; *total_len = 0; kbuf = message_key_pid(pid_to_procid(sys_getpid())); if (tdb_chainlock(tdb, kbuf) == -1) return False; dbuf = tdb_fetch(tdb, kbuf); /* * Replace with an empty record to keep the allocated * space in the tdb. */ tdb_store(tdb, kbuf, null_dbuf, TDB_REPLACE); tdb_chainunlock(tdb, kbuf); if (dbuf.dptr == NULL || dbuf.dsize == 0) { SAFE_FREE(dbuf.dptr); return False; } *msgs_buf = dbuf.dptr; *total_len = dbuf.dsize; return True; }
static void msg_inject_fault(int msg_type, struct process_id src, void *buf, size_t len, void *private_data) { int sig; if (len != sizeof(int)) { DEBUG(0, ("Process %llu sent bogus signal injection request\n", (unsigned long long)src.pid)); return; } sig = *(int *)buf; if (sig == -1) { exit_server("internal error injected"); return; } #if HAVE_STRSIGNAL DEBUG(0, ("Process %llu requested injection of signal %d (%s)\n", (unsigned long long)src.pid, sig, strsignal(sig))); #else DEBUG(0, ("Process %llu requested injection of signal %d\n", (unsigned long long)src.pid, sig)); #endif kill(sys_getpid(), sig); }
/******************************************************************* report a fault ********************************************************************/ static void fault_report(int sig) { static int counter; if (counter) _exit(1); counter++; DEBUGSEP(0); DEBUG(0,("INTERNAL ERROR: Signal %d in pid %d (%s)",sig,(int)sys_getpid(),SAMBA_VERSION_STRING)); DEBUG(0,("\nPlease read the Trouble-Shooting section of the Samba3-HOWTO\n")); DEBUG(0,("\nFrom: http://www.samba.org/samba/docs/Samba3-HOWTO.pdf\n")); DEBUGSEP(0); smb_panic("internal error"); if (cont_fn) { cont_fn(NULL); #ifdef SIGSEGV CatchSignal(SIGSEGV,SIGNAL_CAST SIG_DFL); #endif #ifdef SIGBUS CatchSignal(SIGBUS,SIGNAL_CAST SIG_DFL); #endif #ifdef SIGABRT CatchSignal(SIGABRT,SIGNAL_CAST SIG_DFL); #endif return; /* this should cause a core dump */ } exit(1); }
void start(void) { volatile int checker = 0; /* This variable checks that you correctly gave the child process a new stack. */ pid_t p; int status; app_printf("About to start a new process...\n"); p = sys_fork(); if (p == 0) run_child(); else if (p > 0) { app_printf("Main process %d!\n", sys_getpid()); do { status = sys_wait(p); app_printf("W"); } while (status == WAIT_TRYAGAIN); app_printf("Child %d exited with status %d!\n", p, status); // Check whether the child process corrupted our stack. // (This check doesn't find all errors, but it helps.) if (checker != 0) { app_printf("Error: stack collision!\n"); sys_exit(1); } else sys_exit(0); } else { app_printf("Error!\n"); sys_exit(1); } }
static BOOL irix_oplocks_available(void) { int fd; int pfd[2]; pstring tmpname; oplock_set_capability(True, False); slprintf(tmpname,sizeof(tmpname)-1, "%s/koplock.%d", lp_lockdir(), (int)sys_getpid()); if(pipe(pfd) != 0) { DEBUG(0,("check_kernel_oplocks: Unable to create pipe. Error was %s\n", strerror(errno) )); return False; } if((fd = sys_open(tmpname, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0600)) < 0) { DEBUG(0,("check_kernel_oplocks: Unable to open temp test file %s. Error was %s\n", tmpname, strerror(errno) )); unlink( tmpname ); close(pfd[0]); close(pfd[1]); return False; } unlink(tmpname); if(sys_fcntl_long(fd, F_OPLKREG, pfd[1]) == -1) { DEBUG(0,("check_kernel_oplocks: Kernel oplocks are not available on this machine. \ Disabling kernel oplock support.\n" )); close(pfd[0]); close(pfd[1]); close(fd); return False; }
BOOL is_locked(uint16 smbpid, files_struct * fsp, struct vfs_connection_struct *conn, SMB_BIG_UINT count, SMB_BIG_UINT offset, enum brl_type lock_type) { int snum = conn->snum; BOOL ret; if (count == 0) return (False); if (!lp_locking(snum) || !lp_strict_locking(snum)) return (False); ret = !brl_locktest(fsp->sbuf.st_dev, fsp->sbuf.st_ino, fsp->fnum, smbpid, sys_getpid(), conn->snum, offset, count, lock_type); /* * There is no lock held by an SMB daemon, check to * see if there is a POSIX lock from a UNIX or NFS process. */ if (!ret && lp_posix_locking(snum)) ret = is_posix_locked(fsp, offset, count, lock_type); return ret; }
static pid_t parse_dest(const char *dest) { pid_t pid; /* Zero is a special return value for broadcast smbd */ if (strequal(dest, "smbd")) return 0; /* Try self - useful for testing */ if (strequal(dest, "self")) return sys_getpid(); /* Check for numeric pid number */ if ((pid = atoi(dest)) != 0) return pid; /* Look up other destinations in pidfile directory */ if ((pid = pidfile_pid(dest)) != 0) return pid; fprintf(stderr,"Can't find pid for destination '%s'\n", dest); return -1; }
static void msg_inject_fault(struct messaging_context *msg, void *private_data, uint32_t msg_type, struct server_id src, DATA_BLOB *data) { int sig; if (data->length != sizeof(sig)) { DEBUG(0, ("Process %s sent bogus signal injection request\n", procid_str_static(&src))); return; } sig = *(int *)data->data; if (sig == -1) { exit_server("internal error injected"); return; } #if HAVE_STRSIGNAL DEBUG(0, ("Process %s requested injection of signal %d (%s)\n", procid_str_static(&src), sig, strsignal(sig))); #else DEBUG(0, ("Process %s requested injection of signal %d\n", procid_str_static(&src), sig)); #endif kill(sys_getpid(), sig); }
void process_main(void) { // Fork a total of three new copies. pid_t p = sys_fork(); assert(p >= 0); p = sys_fork(); assert(p >= 0); // The rest of this code is like p-allocator.c. p = sys_getpid(); srand(p); heap_top = ROUNDUP((uint8_t *) end, PAGESIZE); stack_bottom = ROUNDDOWN((uint8_t *) read_esp() - 1, PAGESIZE); while (1) { if ((rand() % ALLOC_SLOWDOWN) < p) { if (heap_top == stack_bottom || sys_page_alloc(heap_top) < 0) break; *heap_top = p; /* check we have write access to new page */ heap_top += PAGESIZE; } sys_yield(); } // After running out of memory, do nothing forever while (1) sys_yield(); }
static bool do_winbind_onlinestatus(struct messaging_context *msg_ctx, const struct server_id pid, const int argc, const char **argv) { struct server_id myid; myid = pid_to_procid(sys_getpid()); if (argc != 1) { fprintf(stderr, "Usage: smbcontrol winbindd onlinestatus\n"); return False; } messaging_register(msg_ctx, NULL, MSG_WINBIND_ONLINESTATUS, print_pid_string_cb); if (!send_message(msg_ctx, pid, MSG_WINBIND_ONLINESTATUS, &myid, sizeof(myid))) return False; wait_replies(msg_ctx, procid_to_pid(&pid) == 0); /* No replies were received within the timeout period */ if (num_replies == 0) printf("No replies received\n"); messaging_deregister(msg_ctx, MSG_WINBIND_ONLINESTATUS, NULL); return num_replies; }
static bool do_winbind_validate_cache(struct messaging_context *msg_ctx, const struct server_id pid, const int argc, const char **argv) { struct server_id myid = pid_to_procid(sys_getpid()); if (argc != 1) { fprintf(stderr, "Usage: smbcontrol winbindd validate-cache\n"); return False; } messaging_register(msg_ctx, NULL, MSG_WINBIND_VALIDATE_CACHE, winbind_validate_cache_cb); if (!send_message(msg_ctx, pid, MSG_WINBIND_VALIDATE_CACHE, &myid, sizeof(myid))) { return False; } wait_replies(msg_ctx, procid_to_pid(&pid) == 0); if (num_replies == 0) { printf("No replies received\n"); } messaging_deregister(msg_ctx, MSG_WINBIND_VALIDATE_CACHE, NULL); return num_replies; }
// P2 - setting priority int sys_setpri(void) { //return -10; int num = -1; argint(0, &num); //return num; if ((num != 1) && (num != 2)) { return -1; } int pid = sys_getpid(); struct proc *p; //return NPROC; acquire(&ptable.lock); for (p = ptable.proc; p < &ptable.proc[NPROC]; p++) { if (p -> pid == pid) { if (p -> priority != num) { p -> priority = num; break; } } } release(&ptable.lock); return 0; }
/******************************************************************* report a fault ********************************************************************/ static void fault_report(int sig) { static int counter; if (counter) _exit(1); counter++; DEBUG(0,("===============================================================\n")); DEBUG(0,("INTERNAL ERROR: Signal %d in pid %d (%s)",sig,(int)sys_getpid(),VERSION)); DEBUG(0,("\nPlease read the file BUGS.txt in the distribution\n")); DEBUG(0,("===============================================================\n")); smb_panic("internal error"); if (cont_fn) { cont_fn(NULL); #ifdef SIGSEGV CatchSignal(SIGSEGV,SIGNAL_CAST SIG_DFL); #endif #ifdef SIGBUS CatchSignal(SIGBUS,SIGNAL_CAST SIG_DFL); #endif return; /* this should cause a core dump */ } exit(1); }
/***************************************************************************** 函 数 名 : trace_counter 功能描述 : Add log with the "counter format" to trace_marker which will be dumped by systrace. 输入参数 : 无 输出参数 : 无 返 回 值 : 调用函数 : 被调函数 : 修改历史 : 1.日 期 : 2014年5月29日 作 者 : shiwanglai 修改内容 : 新生成函数 *****************************************************************************/ void trace_counter(int tag, const char*name, int value) { char buf[MAX_LEN]; snprintf(buf, MAX_LEN, "C|%ld|%s|%d", sys_getpid(), name, value); trace_printk(buf); }
/***************************************************************************** 函 数 名 : trace_begin 功能描述 : Add log with the "begin format" to trace_marker which will be dumped by systrace. 输入参数 : i 输出参数 : 无 返 回 值 : i 调用函数 : 被调函数 : 修改历史 : 1.日 期 : 2014年5月29日 作 者 : shiwanglai 修改内容 : 新生成函数 *****************************************************************************/ void trace_begin(int tag, const char* name) { char buf[MAX_LEN]; snprintf(buf, MAX_LEN, "B|%ld|%s", sys_getpid(), name); trace_printk(buf); }
sigset_t xmutex_lock(struct xmutex * lock) { TRACE(MUTEX, "thread %d:%d is locking %p\n", sys_getpid(), sys_gettid(), lock); int c; sigset_t sigset = block_signals(); if ((c = atomic_cmpxchg(&lock->val, 0, 1)) != 0) { do { if (c == 2 || atomic_cmpxchg(&lock->val, 1, 2) != 0) futex_wait(&lock->val, 2); } while ((c = atomic_cmpxchg(&lock->val, 0, 2)) != 0); } TRACE(MUTEX, "thread %d:%d gained lock %p\n", sys_getpid(), sys_gettid(), lock); return sigset; }
/** * Use a TDB to store an incrementing random seed. * * Initialised to the current pid, the very first time Samba starts, * and incremented by one each time it is needed. * * @note Not called by systems with a working /dev/urandom. */ static void get_rand_seed(void *userdata, int *new_seed) { *new_seed = sys_getpid(); if (db_ctx) { dbwrap_trans_change_int32_atomic(db_ctx, "INFO/random_seed", new_seed, 1); } }
void pmain(void) { volatile int checker = 30; /* This variable checks for some common stack errors. */ pid_t p; int i, status; app_printf("About to start a new process...\n"); p = sys_fork(); if (p == 0) { // Check that the kernel correctly copied the parent's stack. check(checker, 30, "new child"); checker = 30 + sys_getpid(); // Yield several times to help test Exercise 3 app_printf("Child process %d!\n", sys_getpid()); for (i = 0; i < 20; i++) sys_yield(); // Check that no one else corrupted our stack. check(checker, 30 + sys_getpid(), "end child"); sys_exit(1000); } else if (p > 0) { // Check that the child didn't corrupt our stack. check(checker, 30, "main parent"); app_printf("Main process %d!\n", sys_getpid()); do { status = sys_wait(p); } while (status == WAIT_TRYAGAIN); app_printf("Child %d exited with status %d!\n", p, status); check(status, 1000, "sys_wait for child"); // Check again that the child didn't corrupt our stack. check(checker, 30, "end parent"); sys_exit(0); } else { app_printf("Error!\n"); sys_exit(1); } }
/* create a pid file in the pid directory. open it and leave it locked */ void pidfile_create(const char *program_name) { int fd; char buf[20]; char *short_configfile; pstring name; pstring pidFile; pid_t pid; /* Add a suffix to the program name if this is a process with a * none default configuration file name. */ if (strcmp( CONFIGFILE, dyn_CONFIGFILE) == 0) { strncpy( name, program_name, sizeof( name)-1); } else { short_configfile = strrchr( dyn_CONFIGFILE, '/'); if (short_configfile == NULL) { /* conf file in current directory */ short_configfile = dyn_CONFIGFILE; } else { /* full/relative path provided */ short_configfile++; } slprintf( name, sizeof( name)-1, "%s-%s", program_name, short_configfile ); } slprintf(pidFile, sizeof(pidFile)-1, "%s/%s.pid", lp_piddir(), name); pid = pidfile_pid(name); if (pid != 0) { DEBUG(0,("ERROR: %s is already running. File %s exists and process id %d is running.\n", name, pidFile, (int)pid)); exit(1); } fd = sys_open(pidFile, O_NONBLOCK | O_CREAT | O_WRONLY | O_EXCL, 0644); if (fd == -1) { DEBUG(0,("ERROR: can't open %s: Error was %s\n", pidFile, strerror(errno))); exit(1); } if (fcntl_lock(fd,SMB_F_SETLK,0,1,F_WRLCK)==False) { DEBUG(0,("ERROR: %s : fcntl lock of file %s failed. Error was %s\n", name, pidFile, strerror(errno))); exit(1); } memset(buf, 0, sizeof(buf)); slprintf(buf, sizeof(buf) - 1, "%u\n", (unsigned int) sys_getpid()); if (write(fd, buf, strlen(buf)) != (ssize_t)strlen(buf)) { DEBUG(0,("ERROR: can't write to file %s: %s\n", pidFile, strerror(errno))); exit(1); } /* Leave pid file open & locked for the duration... */ }
int mutex_trylock(mutex_t* mtx) { if(unlikely(!mtx)) return E_ERR; if(mtx->owner != sys_getpid()) { if(spinlock_trylock(&mtx->lock) == E_ERR) return E_ERR; mtx->owner = sys_getpid(); mtx->recursion = 0; } else if(mtx->kind == MTX_KIND_ERRORCHECK) return E_ERR; if(mtx->kind == MTX_KIND_RECURSIVE) mtx->recursion += 1; return E_OK; }
static BOOL irix_oplocks_available(void) { int fd; int pfd[2]; pstring tmpname; set_effective_capability(KERNEL_OPLOCK_CAPABILITY); slprintf(tmpname,sizeof(tmpname)-1, "%s/koplock.%d", lp_lockdir(), (int)sys_getpid()); if(pipe(pfd) != 0) { DEBUG(0,("check_kernel_oplocks: Unable to create pipe. Error " "was %s\n", strerror(errno) )); return False; } if((fd = sys_open(tmpname, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0600)) < 0) { DEBUG(0,("check_kernel_oplocks: Unable to open temp test file " "%s. Error was %s\n", tmpname, strerror(errno) )); unlink( tmpname ); close(pfd[0]); close(pfd[1]); return False; } unlink(tmpname); if(sys_fcntl_long(fd, F_OPLKREG, pfd[1]) == -1) { DEBUG(0,("check_kernel_oplocks: Kernel oplocks are not " "available on this machine. Disabling kernel oplock " "support.\n" )); close(pfd[0]); close(pfd[1]); close(fd); return False; } if(sys_fcntl_long(fd, F_OPLKACK, OP_REVOKE) < 0 ) { DEBUG(0,("check_kernel_oplocks: Error when removing kernel " "oplock. Error was %s. Disabling kernel oplock " "support.\n", strerror(errno) )); close(pfd[0]); close(pfd[1]); close(fd); return False; } close(pfd[0]); close(pfd[1]); close(fd); return True; }
BOOL dbghdr( int level, const char *file, const char *func, int line ) { /* Ensure we don't lose any real errno value. */ int old_errno = errno; if( format_pos ) { /* This is a fudge. If there is stuff sitting in the format_bufr, then * the *right* thing to do is to call * format_debug_text( "\n" ); * to write the remainder, and then proceed with the new header. * Unfortunately, there are several places in the code at which * the DEBUG() macro is used to build partial lines. That in mind, * we'll work under the assumption that an incomplete line indicates * that a new header is *not* desired. */ return( True ); } #ifdef WITH_SYSLOG /* Set syslog_level. */ syslog_level = level; #endif /* Don't print a header if we're logging to stdout. */ if( stdout_logging ) return( True ); /* Print the header if timestamps are turned on. If parameters are * not yet loaded, then default to timestamps on. */ if( lp_timestamp_logs() || !(lp_loaded()) ) { char header_str[200]; header_str[0] = '\0'; if( lp_debug_pid()) slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid()); if( lp_debug_uid()) { size_t hs_len = strlen(header_str); slprintf(header_str + hs_len, sizeof(header_str) - 1 - hs_len, ", effective(%u, %u), real(%u, %u)", (unsigned int)geteuid(), (unsigned int)getegid(), (unsigned int)getuid(), (unsigned int)getgid()); } /* Print it all out at once to prevent split syslog output. */ (void)Debug1( "[%s, %d%s] %s:%s(%d)\n", timestring(lp_debug_hires_timestamp()), level, header_str, file, func, line ); } errno = old_errno; return( True ); }
static NTSTATUS do_lock(files_struct *fsp,connection_struct *conn, uint16 lock_pid, SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type) { NTSTATUS status; if (!lp_locking(SNUM(conn))) return NT_STATUS_OK; /* NOTE! 0 byte long ranges ARE allowed and should be stored */ DEBUG(10,("do_lock: lock type %s start=%.0f len=%.0f requested for file %s\n", lock_type_name(lock_type), (double)offset, (double)count, fsp->fsp_name )); if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) { status = brl_lock(fsp->dev, fsp->inode, fsp->fnum, lock_pid, sys_getpid(), conn->cnum, offset, count, lock_type); if (NT_STATUS_IS_OK(status) && lp_posix_locking(SNUM(conn))) { /* * Try and get a POSIX lock on this range. * Note that this is ok if it is a read lock * overlapping on a different fd. JRA. */ if (!set_posix_lock(fsp, offset, count, lock_type)) { status = NT_STATUS_LOCK_NOT_GRANTED; /* * We failed to map - we must now remove the brl * lock entry. */ (void)brl_unlock(fsp->dev, fsp->inode, fsp->fnum, lock_pid, sys_getpid(), conn->cnum, offset, count, False); } } } return status; }