int __init p_init(void)
{
#ifdef MODULE
// SET_MODULE_OWNER(&p_fops_mdaa);
#endif
memset(pipes, 0, sizeof(pipes));
(pipes[0].mda) = create_proc_entry("a.mda", 0, NULL);
(pipes[0].mda)->proc_fops = &p_fops_mdaa;
(pipes[0].idx) = create_proc_entry("a.idx", 0, NULL);
(pipes[0].idx)->proc_fops = &p_fops_idxa;
sema_init(&(SEMAPHO(0)), 1);
init_waitqueue_head(&(RQ(0)));
init_waitqueue_head(&(WQ(0)));
#ifdef DOUBLE_DEV
(pipes[1].mda) = create_proc_entry("b.mda", 0, NULL);
(pipes[1].mda)->proc_fops = &p_fops_mdab;
(pipes[1].idx) = create_proc_entry("b.idx", 0, NULL);
(pipes[1].idx)->proc_fops = &p_fops_idxb;
sema_init(&(SEMAPHO(1)), 1);
init_waitqueue_head(&(RQ(1)));
init_waitqueue_head(&(WQ(1)));
#endif
// init khttp --carl.
#ifdef KERNEL_PIPE
printk("\033[1;33mNew kernel pipe 0717_2007................\033[0m\n");
kpipe_init();
#endif
return 0;
}
// insert a written block.
int proc_insertBuff(int index,int pathIndex,struct block *buff,loff_t pos, size_t count,context *ct)
{
loff_t* f_pos,spos;
size_t left = count, wrt;
int ret;
if(RELEASE(index)) return count;
if(pathIndex==INDEX_PATH_NUM) {
spos = ((pipes[index].ct)[CONTEXT]).bpos + pos;
} else {
spos=pos;
}
f_pos=(loff_t *)&spos;
while(1) {
Down(index);
wrt = left;
ret = dev_insertBuff(&((pipes[index]).device), f_pos,buff, &left, ct);
if(pathIndex==INDEX_PATH_NUM)
POS(ct)=*f_pos-((pipes[index].ct)[CONTEXT]).bpos;
else
POS(ct)=*f_pos;
if(ret == DEV_FAULT) {Up(index); return -EFAULT;}
if(wrt && !R_ABLE(ct)) {
R_ABLE(ct) = 1;
if(ret == DEV_SEEK) {
wake_up_interruptible_sync(&(RQ(index)));
}
else {
wake_up_interruptible(&(RQ(index)));
}
}
if(ret == DEV_SEEK) {Up(index); return -P_ESEEK;}
if(ret == DEV_FULL) {
W_ABLE(ct) = 0; Up(index);
PDEBUG("<%d>: device full, sleep, left %d\n", current->pid, (int)left);
Wait_Event(WQ(index), RELEASE(index)||W_ABLE(ct));
if(RELEASE(index)) return count;
continue;
}
Up(index);
if(left <= 0) break;
}
return count;
}
void GQR
( Matrix<F>& A, Matrix<F>& tA, Matrix<Base<F>>& dA,
Matrix<F>& B, Matrix<F>& tB, Matrix<Base<F>>& dB )
{
DEBUG_ONLY(CallStackEntry cse("GQR"))
QR( A, tA, dA );
qr::ApplyQ( LEFT, ADJOINT, A, tA, dA, B );
RQ( B, tB, dB );
}
static ssize_t p_write(int index, struct file* filp, const char* buf, size_t count, loff_t* f_pos)
{
context *ct = filp->private_data;
size_t left = count, wrt;
int ret;
if(RELEASE(index)) return count;
while(1) {
Down(index);
wrt = left;
ret = dev_write(&((pipes[index]).device), f_pos, buf+(count-left), &left, ct);
if(ret == DEV_FAULT) {Up(index); return -EFAULT;}
#ifdef __PIPE_SELECT
pipes[index].r_poll = 1;
#endif
if(wrt) {
R_ABLE(ct) = 1;
if(ret == DEV_SEEK) {
wake_up_interruptible_sync(&(RQ(index)));
}
else {
wake_up_interruptible(&(RQ(index)));
}
}
if(ret == DEV_SEEK) {Up(index); return -P_ESEEK;}
if(ret == DEV_FULL) {
W_ABLE(ct) = 0; Up(index);
PDEBUG("<%d>: device full, sleep, left %d\n", current->pid, (int)left);
Wait_Event(WQ(index), RELEASE(index)||W_ABLE(ct));
if(RELEASE(index)) return count;
continue;
}
Up(index);
if(left <= 0) break;
}
return count;
}
static unsigned int p_poll(int index, struct file *filp, poll_table *wait)
{
unsigned int mask = 0;
pipe_file *pp = &(pipes[index]);
#ifdef KERNEL_PIPE
if(pipeType[index]>=PIPE_TYPE_KERNEL_THREAD)
return (POLLIN|POLLRDNORM);
#endif
poll_wait(filp, &(RQ(index)), wait);
if(pp->r_poll || dev_search(&(pp->device), pp->r_pos, (pp->device).head)){
if(pp->r_poll) pp->r_poll = 0;
mask |= POLLIN | POLLRDNORM; /* readable */
}
return mask;
}
ValueInt<Base<F>> InverseFreeSignDivide( ElementalMatrix<F>& XPre )
{
DEBUG_CSE
DistMatrixReadWriteProxy<F,F,MC,MR> XProx( XPre );
auto& X = XProx.Get();
typedef Base<F> Real;
const Grid& g = X.Grid();
const Int n = X.Width();
if( X.Height() != 2*n )
LogicError("Matrix should be 2n x n");
// Expose A and B, and then copy A
auto B = X( IR(0,n ), ALL );
auto A = X( IR(n,2*n), ALL );
DistMatrix<F> ACopy( A );
// Run the inverse-free alternative to Sign
InverseFreeSign( X );
// Compute the pivoted QR decomp of inv(A + B) A [See LAWN91]
// 1) B := A + B
// 2) [Q,R,Pi] := QRP(A)
// 3) B := Q^H B
// 4) [R,Q] := RQ(B)
B += A;
DistMatrix<F,MD,STAR> t(g);
DistMatrix<Base<F>,MD,STAR> d(g);
DistMatrix<Int,VR,STAR> p(g);
QR( A, t, d, p );
qr::ApplyQ( LEFT, ADJOINT, A, t, d, B );
RQ( B, t, d );
// A := Q^H A Q
A = ACopy;
rq::ApplyQ( LEFT, ADJOINT, B, t, d, A );
rq::ApplyQ( RIGHT, NORMAL, B, t, d, A );
// Return || E21 ||1 / || A ||1
// Return || E21 ||1 / || A ||1
ValueInt<Real> part = ComputePartition( A );
part.value /= OneNorm(ACopy);
return part;
}
Base<F> InverseFreeSignDivide( Matrix<F>& X )
{
DEBUG_CSE
typedef Base<F> Real;
const Int n = X.Width();
if( X.Height() != 2*n )
LogicError("Matrix should be 2n x n");
// Expose A and B, and then copy A
auto B = X( IR(0,n ), ALL );
auto A = X( IR(n,2*n), ALL );
Matrix<F> ACopy( A );
// Run the inverse-free alternative to Sign
InverseFreeSign( X );
// Compute the pivoted QR decomp of inv(A + B) A [See LAWN91]
// 1) B := A + B
// 2) [Q,R,Pi] := QRP(A)
// 3) B := Q^H B
// 4) [R,Q] := RQ(B)
B += A;
Matrix<F> t;
Matrix<Base<F>> d;
Matrix<Int> p;
QR( A, t, d, p );
qr::ApplyQ( LEFT, ADJOINT, A, t, d, B );
RQ( B, t, d );
// A := Q^H A Q
A = ACopy;
rq::ApplyQ( LEFT, ADJOINT, B, t, d, A );
rq::ApplyQ( RIGHT, NORMAL, B, t, d, A );
// Return || E21 ||1 / || A ||1
ValueInt<Real> part = ComputePartition( A );
part.value /= OneNorm(ACopy);
return part;
}
SimpleCamera simpleCamera(const Matrix& P) {
// P = [A|a] = s K cRw [I|-T], with s the unknown scale
Matrix A = P.topLeftCorner(3, 3);
Vector a = P.col(3);
// do RQ decomposition to get s*K and cRw angles
Matrix sK;
Vector xyz;
boost::tie(sK, xyz) = RQ(A);
// Recover scale factor s and K
double s = sK(2, 2);
Matrix K = sK / s;
// Recover cRw itself, and its inverse
Rot3 cRw = Rot3::RzRyRx(xyz);
Rot3 wRc = cRw.inverse();
// Now, recover T from a = - s K cRw T = - A T
Vector T = -(A.inverse() * a);
return SimpleCamera(Pose3(wRc, T),
Cal3_S2(K(0, 0), K(1, 1), K(0, 1), K(0, 2), K(1, 2)));
}
static int p_release(int index, struct inode* inode, struct file* filp)
{
#ifdef __PIPE_SELECT__
pipe_file *pp = &(pipes[index]);
#endif
#ifdef KERNEL_PIPE
#ifdef NO_KERNEL_PIPE_THREAD
if (pipeType[index] == PIPE_TYPE_KERNEL_DIRECT) {
sock_pos_t *sp=(sock_pos_t *)filp->private_data;
if(sp && sp->magic==SOCK_POS_MAGIC) {
if(sp->sock) {
sock_release(sp->sock);
sp->sock = NULL;
}
if(sp->request) {
kfree(sp->request);
sp->request = NULL;
sp->leftLen = 0;
sp->leftPos = NULL;
}
kfree(sp);
filp->private_data=NULL;
}
}
#endif
#endif
wake_up_interruptible(&(RQ(index)));
wake_up_interruptible(&(WQ(index)));
#ifdef __PIPE_SELECT__
pp->r_poll = 1;
pp->r_pos = 0;
#endif
rcount--;
return 0;
}
static ssize_t p_read(int index, struct file* filp, char* buf, size_t count, loff_t* f_pos)
{
context *ct = NULL;
size_t left;
int ret;
if(RELEASE(index)) return -ENXIO;
Down(index);
ct = getct(index, *f_pos);
if(*f_pos >= EPOS(ct)) {Up(index); return 0;}
count = (*f_pos+count>EPOS(ct))?(EPOS(ct)-(*f_pos)):(count); left = count;
#ifdef KERNEL_PIPE
#ifdef NO_KERNEL_PIPE_THREAD
if(pipeType[index] == PIPE_TYPE_KERNEL_DIRECT) {
Up(index);
return p_sock_read(index,filp,buf,count,f_pos);
}
#endif
#endif
while(1) {
ret = dev_read(&((pipes[index]).device), f_pos, buf+(count-left), &left, ct);
#ifdef __PIPE_SELECT__
pipes[index].r_pos = *f_pos+(count-left);
#endif
if(ret == DEV_FAULT) {Up(index); return -EFAULT;}
if(!W_ABLE(ct)) {
W_ABLE(ct) = 1;
wake_up_interruptible(&(WQ(index)));
}
if(left>0) {
if(filp->f_flags & O_NONBLOCK) {
#ifdef __PIPE_SELECT__
pipes[index].r_poll = 0;
#endif
Up(index);
if(count == left) return -EAGAIN;
break;
}
R_ABLE(ct) = 0; Up(index);
PDEBUG("<%d>: need more data, sleep\n", current->pid);
Wait_Event(RQ(index), RELEASE(index)||R_ABLE(ct));
#ifdef CONFIG_PROC_PIPE_64_BITS_SUPPORT
if (*f_pos >= pipes[index].mda_size )
#else // CONFIG_PROC_PIPE_64_BITS_SUPPORT
if (*f_pos >= pipes[index].mda->size)
#endif // CONFIG_PROC_PIPE_64_BITS_SUPPORT
return (count - left);
if(RELEASE(index)) return -ENXIO;
Down(index);
}
else {Up(index); break;}
}
return (count - left);
}
static int p_ioctl(int index, struct inode* inode, struct file* filp, unsigned int cmd, unsigned long arg)
{
context *ct = filp->private_data;
pipe_file *pp = &(pipes[index]);
tell_inf t_inf;
size_inf s_inf;
#ifdef KRSA
krsa_arg rsa;
unsigned char *input = NULL, output[MAX_RSA_MODULUS_LEN];
unsigned int inputlen = 0, outputlen = 0;
#endif
int err = 0, ret = 0, i;
if(!capable(CAP_SYS_ADMIN)) return -EPERM;
if(_IOC_TYPE(cmd) != P_IOCMAGIC) return -ENOTTY;
if(_IOC_DIR(cmd) & _IOC_READ) {
err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
}
else if(_IOC_DIR(cmd) & _IOC_WRITE) {
err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
}
if(err) return -EFAULT;
Down(index);
switch(cmd) {
case P_IOCCLEAR:
dev_flush(&(pp->device));
for(i=0; i<=CONTEXT; i++) {
((pp->ct)[i]).hotp = NULL;
}
break;
case P_IOCRESET:
memset(pp->ct, 0, sizeof(context)*(CONTEXT+1));
#ifdef __PIPE_SELECT__
pp->r_poll = 1;
pp->r_pos = 0;
#endif
for(i=0; i<=CONTEXT; i++) {
((pp->ct)[i]).r_able = 1;
((pp->ct)[i]).w_able = 1;
}
RELEASE(index) = 0; WRITERS(index) = 0;
dev_flush(&(pp->device));
(pp->device).ctp = pp->ct;
(pp->device).pred = 2*BUFF_SIZE;
#ifdef KERNEL_PIPE
pipeType[index]=PIPE_TYPE_USER_THREAD;
#endif
break;
case P_IOCSIZE:
if(copy_from_user((char*)&s_inf, (char*)arg, sizeof(size_inf))) {
ret = (-EFAULT); goto my_error;
}
#ifndef CONFIG_PROC_PIPE_64_BITS_SUPPORT
#ifndef CONFIG_PROC_PIPE_KERNEL_SUPPORT_64_BITS
if(s_inf.mdas > 0xFFFFFFFFF || s_inf.idxs > 0xFFFFFFFF) {
ret = (-EFAULT); goto my_error;
}
#endif
(pp->mda)->size = s_inf.mdas;
(pp->idx)->size = s_inf.idxs;
#else // !CONFIG_PROC_PIPE_64_BITS_SUPPORT
#if 0
(pp->mda)->size = s_inf.mdas;
(pp->idx)->size = s_inf.idxs;
#else
(pp->mda)->size = 0;
(pp->idx)->size = 0;
#endif
pp->mda_size = s_inf.mdas;
pp->idx_size = s_inf.idxs;
#endif // !CONFIG_PROC_PIPE_64_BITS_SUPPORT
for(i=0; i<CONTEXT; i++) {
((pp->ct)[i]).epos = s_inf.mdas;
}
((pp->ct)[CONTEXT]).bpos = s_inf.dats;
((pp->ct)[CONTEXT]).epos = s_inf.dats + s_inf.idxs;
((pp->ct)[CONTEXT]).seek = s_inf.dats;
break;
case P_IOCREVS:
((pp->ct)[CONTEXT]).reverse = *((int*)arg);
break;
case P_IOCTELL:
t_inf.seek = filp->f_pos;
t_inf.size = (BPOS(ct))?(BUFF_SIZE):(SIZE(ct));
if(copy_to_user((char*)arg, (char*)&t_inf, sizeof(tell_inf))) {
ret = (-EFAULT); goto my_error;
}
break;
case P_IOCRELS:
RELEASE(index) = 1;
wake_up_interruptible(&(RQ(index)));
wake_up_interruptible(&(WQ(index)));
break;
case P_IOCPRED:
(pp->device).pred = *((size_t*)arg);
break;
#ifdef KRSA
case P_IOCKRSA:
if(copy_from_user((char*)&rsa, (char*)arg, sizeof(krsa_arg))) {
ret = (-EFAULT); goto my_error;
}
if(!access_ok(VERIFY_READ, (void *)(rsa.len), sizeof(unsigned int))) {
ret = (-EFAULT); goto my_error;
}
if(copy_from_user((char*)&inputlen, (char*)(rsa.len), sizeof(unsigned int))) {
ret = (-EFAULT); goto my_error;
}
if(!(input = kmalloc(inputlen, GFP_KERNEL))) {
ret = (-EFAULT); goto my_error;
}
if(!access_ok(VERIFY_READ, (void *)(rsa.buf), inputlen)) {
ret = (-EFAULT); goto my_error;
}
if(copy_from_user((char*)input, (char*)(rsa.buf), inputlen)) {
ret = (-EFAULT); goto my_error;
}
if(RSAPrivateBlock(output, &outputlen, input, inputlen, &(rsa.key))) {
ret = (-EFAULT); goto my_error;
}
if(!access_ok(VERIFY_WRITE, (void *)(rsa.buf), outputlen)) {
ret = (-EFAULT); goto my_error;
}
if(copy_to_user((char*)(rsa.buf), (char*)output, outputlen)) {
ret = (-EFAULT); goto my_error;
}
if(!access_ok(VERIFY_WRITE, (void *)(rsa.len), sizeof(unsigned int))) {
ret = (-EFAULT); goto my_error;
}
if(copy_to_user((char*)(rsa.len), (char*)&outputlen, sizeof(unsigned int))) {
ret = (-EFAULT); goto my_error;
}
break;
#endif
#ifdef KERNEL_PIPE
case P_IOCPIPETYPE:
{
int val;
get_user(val,(int *)arg);
if(val<0) {
ret= -EFAULT;
break;
}
#ifdef NO_KERNEL_PIPE_THREAD
if(val<=PIPE_TYPE_KERNEL_DIRECT)
#else
if(val<=PIPE_TYPE_KERNEL_THREAD)
#endif
pipeType[index]=val;
else
ret= -EFAULT;
}
break;
case P_IOCPIPESTART:
{
// int len;
kpipe_setup userPath;
kpipe_setup *pipeSetup;
pipe_thread *pipeThread;
DECLARE_WAIT_QUEUE_HEAD(WQ);
copy_from_user(&userPath,(kpipe_setup *)arg,sizeof(kpipe_setup));
pipeSetup=pipeManage.threads[index].pipeSetup;
pipeThread=&(pipeManage.threads[index]);
//select a default pipe type.
if(pipeType[index]==PIPE_TYPE_USER_THREAD)
pipeType[index]=defaultPipeType;
if(pipeType[index]!=PIPE_TYPE_KERNEL_THREAD && pipeType[index]!=PIPE_TYPE_KERNEL_DIRECT)
pipeType[index]=PIPE_TYPE_KERNEL_DIRECT;
//pipe_type_kernel_direct doesn't support local file.
#ifdef NO_KERNEL_PIPE_THREAD
if(pipeType[index]==PIPE_TYPE_KERNEL_DIRECT) {
if(userPath.type>PIPE_KP) {
ret = -EFAULT;
break;
}
}
#endif
if(*(pipeSetup->host)) //if it has used already? a.dma or a.index.
pipeSetup++;
if(*(pipeSetup->host)) {
HDEBUG("no pipeSetup\n");
ret = -EFAULT;
break;
}
pipeThread->index = index; //a or b.
pipeSetup->index = index;
// copy_from_user(&pipeSetup->nums,&userPath.nums,1);
pipeSetup->nums = userPath.nums;
// copy_from_user(&pipeSetup->size,&((kpipe_setup *)arg)->size,sizeof(int));
pipeSetup->size = userPath.size;
// copy_from_user(&httpThread->type,&((kpipe_setup *)arg)->type,1);
pipeThread->type = userPath.type; //close or keep alive.
memcpy(pipeSetup->host,userPath.host,16);
memcpy(pipeSetup->procfile,userPath.procfile,16);
if(!strcmp(pipeSetup->procfile+strlen("/proc/a."),"mda")) {
pipeSetup->pathIndex = MEDIA_PATH_NUM; //dma or index.
} else {
pipeSetup->pathIndex = INDEX_PATH_NUM;
}
// pipeSetup->host=HTTP_MALLOC(strlen(userPath->host)+1);
pipeSetup->path=HTTP_MALLOC(userPath.pathSize);
// pipeSetup->sessionid=HTTP_MALLOC(((kpipe_setup *)arg)->sessionidSize);
if(!pipeSetup->path) {
// no memroy.
}
copy_from_user(pipeSetup->path,userPath.path,userPath.pathSize);
if(userPath.sessionid){
pipeSetup->sessionid=HTTP_MALLOC(userPath.sessionidSize);
copy_from_user(pipeSetup->sessionid,userPath.sessionid,userPath.sessionidSize);
}
// copy_from_user(&(pipeSetup->port),&userPath.port),sizeof(short));
pipeSetup->port = userPath.port;
// copy_from_user(&(pipeSetup->protection),&(((kpipe_setup *)arg)->protection),sizeof(int));
pipeSetup->protection = userPath.protection;
HDEBUG("ioctl:%s %d:%s\n",pipeSetup->host,pipeSetup->port,pipeSetup->path);
//pipeManage.starts[index][pipeSetup->index].start=1;
if(pipeType[index]==PIPE_TYPE_KERNEL_THREAD) {
down_interruptible(&(pipeManage.semaphore));
atomic_set(&(pipeManage.starts[index][pipeSetup->pathIndex]),1); //start kernel_thread.
//to wakeup manage thread.
while(pipeManage.change) {
interruptible_sleep_on_timeout(&WQ,5);
}
pipeManage.change=1;
up(&(pipeManage.semaphore));
wake_up_interruptible(&(pipeManage.wq));
}
}
break;
case P_IOCPIPESTOP:
{
pipe_thread *thread=&(pipeManage.threads[index]);
int i;
DECLARE_WAIT_QUEUE_HEAD(WQ);
RELEASE(index) = 1;
if(pipeType[index]==PIPE_TYPE_KERNEL_THREAD) {
wake_up_interruptible(&(RQ(index)));
wake_up_interruptible(&(WQ(index)));
down_interruptible(&(pipeManage.semaphore));
atomic_set(&(pipeManage.stops[index]),1);
//to wakeup manage thread.
while(pipeManage.change) {
interruptible_sleep_on_timeout(&WQ,5);
}
pipeManage.change = 1;
up(&(pipeManage.semaphore));
wake_up_interruptible(&(pipeManage.wq));
}
else {
for(i=0;i<END_PATH_NUM;i++) {
if(thread->pipeSetup[i].path) {
HTTP_FREE(thread->pipeSetup[i].path);
if(thread->pipeSetup[i].sessionid)
HTTP_FREE(thread->pipeSetup[i].sessionid);
memset(&(thread->pipeSetup[i]),0,sizeof(kpipe_setup));
}
}
}
}
break;
#endif
default:
ret = (-ENOTTY);
}
my_error:
#ifdef KRSA
if(input) kfree(input);
#endif
Up(index);
return ret;
}
/* ************************************************************************* */
Vector3 Rot3::xyz() const {
Matrix3 I;Vector3 q;
boost::tie(I,q)=RQ(matrix());
return q;
}
