/* bench_io.c — metadatos de FS, resolucion de rutas, copia, io_uring, fallos de pagina, namespaces. */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>
#include <sched.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <sys/sendfile.h>
#include <dirent.h>
#include <linux/openat2.h>
#include <liburing.h>

extern char **environ;
static volatile long sink;
static inline double now_ns(void){ struct timespec t; clock_gettime(CLOCK_MONOTONIC,&t); return t.tv_sec*1e9+t.tv_nsec; }
static int cmpd(const void*a,const void*b){ double x=*(const double*)a,y=*(const double*)b; return (x>y)-(x<y); }
#define ROUNDS 7
static void report(const char*n,double*r,int c,long it){ qsort(r,c,sizeof(double),cmpd);
  printf("%-40s %10.1f %10.1f   (n=%ld)\n",n,r[0],r[c/2],it); fflush(stdout); }
#define BENCH(name,iters,...) do{ double _r[ROUNDS]; long _N=(iters); \
  for(int _q=0;_q<ROUNDS;_q++){ double _t0=now_ns(); for(long i=0;i<_N;i++){ __VA_ARGS__; } \
    _r[_q]=(now_ns()-_t0)/(double)_N; } report(name,_r,ROUNDS,_N);}while(0)

#define NFILES 4000
static char root[512];

static void mk_tree(const char *base){
  mkdir(base,0755);
  char p[600]; snprintf(p,sizeof p,"%s/flat",base); mkdir(p,0755);
  for(int i=0;i<NFILES;i++){ char f[700]; snprintf(f,sizeof f,"%s/flat/f%05d",base,i);
    int fd=open(f,O_CREAT|O_WRONLY|O_TRUNC,0644); if(fd>=0){ (void)!write(fd,"x",1); close(fd);} }
  /* ruta profunda: base/d/d/d/... (12 niveles) con un fichero al fondo */
  char deep[600]; snprintf(deep,sizeof deep,"%s/deep",base); mkdir(deep,0755);
  for(int i=0;i<12;i++){ strcat(deep,"/d"); mkdir(deep,0755); }
  char df[700]; snprintf(df,sizeof df,"%s/x",deep);
  int fd=open(df,O_CREAT|O_WRONLY,0644); if(fd>=0){(void)!write(fd,"x",1);close(fd);}
}
static void rm_tree(const char *base){ char c[700]; snprintf(c,sizeof c,"rm -rf '%s'",base); (void)!system(c); }

static void metadata(const char *base,const char *etiqueta){
  char flat[600]; snprintf(flat,sizeof flat,"%s/flat",base);
  int dfd=open(flat,O_RDONLY|O_DIRECTORY);
  printf("\n### metadatos sobre %s (%d ficheros en un directorio)\n",etiqueta,NFILES);
  printf("%-40s %10s %10s\n","BENCH (ns/fichero)","min","mediana");
  BENCH("stat() por ruta completa",           NFILES, {struct stat s;char f[700];snprintf(f,sizeof f,"%s/f%05d",flat,(int)(i%NFILES));sink=stat(f,&s);});
  BENCH("fstatat(dirfd, nombre)",             NFILES, {struct stat s;char f[32];snprintf(f,sizeof f,"f%05d",(int)(i%NFILES));sink=fstatat(dfd,f,&s,0);});
  BENCH("statx(dirfd,nombre,DONT_SYNC)",      NFILES, {struct statx s;char f[32];snprintf(f,sizeof f,"f%05d",(int)(i%NFILES));sink=syscall(SYS_statx,dfd,f,AT_STATX_DONT_SYNC,STATX_BASIC_STATS,&s);});
  BENCH("openat(dirfd,nombre)+close",         NFILES, {char f[32];snprintf(f,sizeof f,"f%05d",(int)(i%NFILES));int fd=openat(dfd,f,O_RDONLY);if(fd>=0)close(fd);});
  { struct open_how how; memset(&how,0,sizeof how); how.flags=O_RDONLY; how.resolve=RESOLVE_BENEATH|RESOLVE_NO_SYMLINKS;
    int probe=syscall(SYS_openat2,dfd,"f00000",&how,sizeof how);
    if(probe>=0){ close(probe);
      BENCH("openat2 RESOLVE_BENEATH+NO_SYMLINKS",NFILES,{char f[32];snprintf(f,sizeof f,"f%05d",(int)(i%NFILES));int fd=syscall(SYS_openat2,dfd,f,&how,sizeof how);if(fd>=0)close(fd);});
    } else printf("openat2: no disponible (%s)\n",strerror(errno)); }
  /* getdents64: barrido completo, coste por entrada */
  { double r[ROUNDS]; long cnt=0;
    for(int q=0;q<ROUNDS;q++){ char buf[65536]; long c=0; double t0=now_ns();
      int fd=open(flat,O_RDONLY|O_DIRECTORY); long n;
      while((n=syscall(SYS_getdents64,fd,buf,sizeof buf))>0){ long off=0; while(off<n){ struct dirent64 *e=(void*)(buf+off); c++; off+=e->d_reclen; } }
      close(fd); r[q]=(now_ns()-t0)/(double)c; cnt=c; }
    report("getdents64 (barrido, sin stat)",r,ROUNDS,cnt); }
  close(dfd);
  /* profundidad de ruta */
  { char shallow[700],deep[700]; snprintf(shallow,sizeof shallow,"%s/flat/f00000",base);
    snprintf(deep,sizeof deep,"%s/deep",base); for(int i=0;i<12;i++) strcat(deep,"/d"); strcat(deep,"/x");
    BENCH("open ruta corta (2 componentes bajo base)",20000,{int fd=open(shallow,O_RDONLY);if(fd>=0)close(fd);});
    BENCH("open ruta 13 componentes mas profunda",   20000,{int fd=open(deep,O_RDONLY);if(fd>=0)close(fd);}); }
}

static void copia(const char *base){
  const long SZ = 64L*1024*1024;
  char src[700],dst[700]; snprintf(src,sizeof src,"%s/src.bin",base); snprintf(dst,sizeof dst,"%s/dst.bin",base);
  int fd=open(src,O_CREAT|O_WRONLY|O_TRUNC,0644);
  char *buf=malloc(1<<20); memset(buf,0xA5,1<<20);
  for(long w=0;w<SZ;w+=1<<20) (void)!write(fd,buf,1<<20);
  close(fd); free(buf);
  printf("\n### copiar %ld MB (fichero en cache de pagina)\n",SZ>>20);
  printf("%-40s %10s %10s\n","BENCH (MB/s)","max","mediana");
  double r[ROUNDS];
  for(int q=0;q<ROUNDS;q++){ int s=open(src,O_RDONLY),d=open(dst,O_CREAT|O_WRONLY|O_TRUNC,0644);
    char b[65536]; ssize_t n; double t0=now_ns(); while((n=read(s,b,sizeof b))>0) (void)!write(d,b,n);
    r[q]=SZ/((now_ns()-t0)/1e9)/1e6; close(s);close(d);} 
  qsort(r,ROUNDS,sizeof(double),cmpd); printf("%-40s %10.1f %10.1f\n","read()+write() 64K",r[ROUNDS-1],r[ROUNDS/2]);
  for(int q=0;q<ROUNDS;q++){ int s=open(src,O_RDONLY),d=open(dst,O_CREAT|O_WRONLY|O_TRUNC,0644);
    off_t off=0; double t0=now_ns(); while(off<SZ){ ssize_t n=sendfile(d,s,&off,SZ-off); if(n<=0)break; }
    r[q]=SZ/((now_ns()-t0)/1e9)/1e6; close(s);close(d);} 
  qsort(r,ROUNDS,sizeof(double),cmpd); printf("%-40s %10.1f %10.1f\n","sendfile()",r[ROUNDS-1],r[ROUNDS/2]);
  for(int q=0;q<ROUNDS;q++){ int s=open(src,O_RDONLY),d=open(dst,O_CREAT|O_WRONLY|O_TRUNC,0644);
    loff_t io=0,oo=0; double t0=now_ns(); long left=SZ;
    while(left>0){ ssize_t n=syscall(SYS_copy_file_range,s,&io,d,&oo,left,0); if(n<=0)break; left-=n; }
    r[q]=SZ/((now_ns()-t0)/1e9)/1e6; close(s);close(d);} 
  qsort(r,ROUNDS,sizeof(double),cmpd); printf("%-40s %10.1f %10.1f\n","copy_file_range()",r[ROUNDS-1],r[ROUNDS/2]);
  /* materializacion de arbol: hardlink vs copia, 2000 ficheros pequeños */
  char lk[700]; snprintf(lk,sizeof lk,"%s/mat",base); mkdir(lk,0755);
  printf("\n### materializar 2000 ficheros de 1 byte (el problema del store)\n");
  BENCH("link() [hardlink]",2000,{char a[700],b[700];snprintf(a,sizeof a,"%s/flat/f%05d",base,(int)i);snprintf(b,sizeof b,"%s/mat/l%05d",base,(int)i);unlink(b);sink=link(a,b);});
  BENCH("open+read+write+close [copia]",2000,{char a[700],b[700];char c[64];snprintf(a,sizeof a,"%s/flat/f%05d",base,(int)i);snprintf(b,sizeof b,"%s/mat/c%05d",base,(int)i);int s=open(a,O_RDONLY),d=open(b,O_CREAT|O_WRONLY|O_TRUNC,0644);ssize_t n=read(s,c,sizeof c);(void)!write(d,c,n);close(s);close(d);});
  unlink(src); unlink(dst);
}

static void uring(const char *base){
  const long SZ=64L*1024*1024; const int BS=4096; const int DEPTH=32;
  char src[700]; snprintf(src,sizeof src,"%s/u.bin",base);
  int fd=open(src,O_CREAT|O_RDWR|O_TRUNC,0644);
  char *b=malloc(1<<20); memset(b,7,1<<20); for(long w=0;w<SZ;w+=1<<20)(void)!write(fd,b,1<<20); free(b);
  fsync(fd);
  printf("\n### 4K aleatorios sobre 64MB en cache: syscall vs io_uring\n");
  printf("%-40s %10s %10s\n","BENCH (ns/lectura)","min","mediana");
  char *buf=aligned_alloc(4096,BS*DEPTH);
  long nblk=SZ/BS;
  BENCH("pread() 4K",50000,{sink=pread(fd,buf,BS,(long)((i*7919)%nblk)*BS);});
  struct io_uring ring;
  if(io_uring_queue_init(256,&ring,0)==0){
    double r[ROUNDS];
    for(int q=0;q<ROUNDS;q++){ long done=0,total=50000; double t0=now_ns();
      while(done<total){ int batch=DEPTH; if(total-done<batch)batch=total-done;
        for(int k=0;k<batch;k++){ struct io_uring_sqe*s=io_uring_get_sqe(&ring);
          io_uring_prep_read(s,fd,buf+k*BS,BS,(long)(((done+k)*7919)%nblk)*BS); }
        io_uring_submit_and_wait(&ring,batch);
        struct io_uring_cqe*c; unsigned h; int seen=0;
        io_uring_for_each_cqe(&ring,h,c){ seen++; } io_uring_cq_advance(&ring,seen);
        done+=batch; }
      r[q]=(now_ns()-t0)/total; }
    report("io_uring read 4K (profundidad 32)",r,ROUNDS,50000);
    /* piso de submission: NOP en lote */
    for(int q=0;q<ROUNDS;q++){ long done=0,total=200000; double t0=now_ns();
      while(done<total){ int batch=64; if(total-done<batch)batch=total-done;
        for(int k=0;k<batch;k++){ struct io_uring_sqe*s=io_uring_get_sqe(&ring); io_uring_prep_nop(s); }
        io_uring_submit_and_wait(&ring,batch);
        struct io_uring_cqe*c; unsigned h; int seen=0;
        io_uring_for_each_cqe(&ring,h,c){ seen++; } io_uring_cq_advance(&ring,seen);
        done+=batch; }
      r[q]=(now_ns()-t0)/total; }
    report("io_uring NOP (piso de operacion)",r,ROUNDS,200000);
    io_uring_queue_exit(&ring);
  } else printf("io_uring: no disponible (%s)\n",strerror(errno));
  free(buf); close(fd); unlink(src);
}

static void memoria(void){
  const long SZ=128L*1024*1024;
  printf("\n### fallos de pagina: tocar 128MB anonimos (ns por pagina de 4K)\n");
  printf("%-40s %10s %10s\n","BENCH","min","mediana");
  double r[ROUNDS]; long pages=SZ/4096;
  for(int q=0;q<ROUNDS;q++){ char*m=mmap(0,SZ,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
    madvise(m,SZ,MADV_HUGEPAGE); double t0=now_ns();
    for(long o=0;o<SZ;o+=4096) m[o]=1; r[q]=(now_ns()-t0)/pages; munmap(m,SZ);} 
  report("MADV_HUGEPAGE (THP)",r,ROUNDS,pages);
  for(int q=0;q<ROUNDS;q++){ char*m=mmap(0,SZ,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
    madvise(m,SZ,MADV_NOHUGEPAGE); double t0=now_ns();
    for(long o=0;o<SZ;o+=4096) m[o]=1; r[q]=(now_ns()-t0)/pages; munmap(m,SZ);} 
  report("MADV_NOHUGEPAGE (4K de a uno)",r,ROUNDS,pages);
  for(int q=0;q<ROUNDS;q++){ double t0=now_ns();
    char*m=mmap(0,SZ,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS|MAP_POPULATE,-1,0);
    for(long o=0;o<SZ;o+=4096) m[o]=1; r[q]=(now_ns()-t0)/pages; munmap(m,SZ);} 
  report("MAP_POPULATE (prefault)",r,ROUNDS,pages);
  BENCH("mmap+munmap 4K (churn)",100000,{void*m=mmap(0,4096,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);munmap(m,4096);});
}

static void namespaces(void){
  printf("\n### coste del sandbox: crear namespaces (us por proceso)\n");
  printf("%-40s %10s %10s\n","BENCH","min","mediana");
  double r[ROUNDS];
  for(int q=0;q<ROUNDS;q++){ int N=100; double t0=now_ns();
    for(int i=0;i<N;i++){ pid_t p=fork(); if(p==0){ char*a[]={"/bin/true",0}; execve(a[0],a,environ); _exit(127);} int st; waitpid(p,&st,0);}    
    r[q]=(now_ns()-t0)/N/1000; } report("fork+exec /bin/true (base)",r,ROUNDS,100);
  int fallo=0;
  for(int q=0;q<ROUNDS;q++){ int N=100; double t0=now_ns();
    for(int i=0;i<N;i++){ pid_t p=fork();
      if(p==0){ if(unshare(CLONE_NEWUSER|CLONE_NEWNS|CLONE_NEWPID|CLONE_NEWIPC|CLONE_NEWUTS|CLONE_NEWNET)<0) _exit(9);
                char*a[]={"/bin/true",0}; execve(a[0],a,environ); _exit(127);}
      int st; waitpid(p,&st,0); if(WEXITSTATUS(st)==9) fallo=1; }
    r[q]=(now_ns()-t0)/N/1000; }
  if(fallo) printf("unshare completo: no permitido para este uid\n");
  else report("fork+unshare(6 ns)+exec",r,ROUNDS,100);
  for(int q=0;q<ROUNDS;q++){ int N=100; double t0=now_ns();
    for(int i=0;i<N;i++){ pid_t p=fork();
      if(p==0){ unshare(CLONE_NEWUSER|CLONE_NEWNS); char*a[]={"/bin/true",0}; execve(a[0],a,environ); _exit(127);}
      int st; waitpid(p,&st,0); }
    r[q]=(now_ns()-t0)/N/1000; } report("fork+unshare(USER|MNT)+exec",r,ROUNDS,100);
}

int main(int argc,char**argv){
  const char *base = argc>1?argv[1]:"/tmp/bench-linux";
  snprintf(root,sizeof root,"%s",base);
  rm_tree(root); mk_tree(root);
  metadata(root, base);
  copia(root);
  uring(root);
  if(argc<=2){ memoria(); namespaces(); }
  rm_tree(root);
  return 0;
}