Confused with pointer arithmetic - c++

Question

Can anyone help me understand what these two lines are doing
buf = (char *)(malloc(2 * pagesize) & pagemask);
buf = (char *)(((long)buf + pagesize) & ∼pagemask);
I understand malloc but not sure what the & operation is trying to achieve in both expressions
Pagesize and pagemask are defined as follows earlier
pagesize = sysconf(_SC_PAGESIZE);
pagemask = pagesize - 1;
Thanks!
Edit1
This code is from a book "Unix FileSystems" by Steve D. Pate
Edit2
This is the full code
#include <sys/unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include “sys/fs/vx_ioctl.h”
#define MB (1024 * 1024)
main(int argc, char argv[])
{
char *buf;
int i, fd, advisory;
long pagesize, pagemask;
if (argc != 2) {
exit(1);
}
if (strcmp(argv[1], “VX_SEQ”) == 0) {
advisory = VX_SEQ;
} else if (strcmp(argv[1], “VX_RANDOM”) == 0) {
advisory = VX_RANDOM;
} else if (strcmp(argv[1], “VX_DIRECT”) == 0) {
advisory = VX_DIRECT;
}
pagesize = sysconf(_SC_PAGESIZE);
pagemask = pagesize - 1;
buf = (char *)(malloc(2 * pagesize) & pagemask);
buf = (char *)(((long)buf + pagesize) & ∼pagemask);
fd = open(“myfile”, O_RDWR);
ioctl(fd, VX_SETCACHE, advisory);
for (i=0 ; i<MB ; i++) {
read(fd, buf, 4096);
}
}

Answer 1

Preliminary Notes
Memory "pages" always (well, effectively always) have a size which is a power of 2. That means that, for a given page size, the upper bits of an address indicate a page, and the lower bits - an offset into the page.
Don't write this kind of code. Make explicit conversions; use multiple, simpler instructions; try using more meaningful variable names (e.g. offset_into_page = ((const uintptr_t) address) & page_mask;) and so on.
First line
The first line does the following:
Allocate 2 pages' worth of memory.
Treating the address as a number, keep only the bits of the offset within the page in which the allocated area begins.
It's not clear to me why this is useful.
Second line
The second line does the following:
Treat the address of buf as a number (although in a crooked, error-prone and non-portable way).
Move one page ahead from the address of buf.
Keep the page bits of the address - obtaining the first page-boundary-aligned address within buf.
This sacrifices some of the space allocated for buf, making it aligned (and keeping it in actually allocated space.