/*

对树进行dfs遍历，形成一个长度为N的序列。

要去掉的两个子树，在dfs序中是连续的。

从整个序列中去掉这两个序列，可能形成二个或三个连续的序列

对序列进行合并求直径。

每个序列有左右端点，形成的新的直径，有四种选择。对于端点之间的距离利用lca来求就好了。

对于文后图标样例，形成一个dfs序列,其中45及78是要去掉的

12 45 6 78 3

于是合并12 6 3这三个区间就好了

*/

#include<cstdio>

#include<iostream>

#include<algorithm>

#define ls now<<1,l,mid

#define rs now<<1|1,mid+1,r

#define rep(i,x) for(int i=head[x],v=e[i].to;i;i=e[i].nxt,v=e[i].to)

using namespace std;

const int maxn=100010;

struct fk

{

	int to,nxt;

}

e[maxn<<1];

int cnt,n,q,tot,head[maxn],dfn[maxn],p[maxn],last[maxn],dep[maxn],f[maxn][20];

struct fq{int sum,x,y;}

t[maxn<<2],ans;

void ins(int u,int v)

{

	e[++cnt].to=v;

	e[cnt].nxt=head[u];

	head[u]=cnt;

}

void dfs(int x,int fa)

{

    dfn[x]=++tot;//x进入的时间点

	p[tot]=x;//第tot个点是x

	f[x][0]=fa;

	dep[x]=dep[fa]+1;

    rep(i,x)

	    if(v!=fa)

		    dfs(v,x);

	last[x]=tot;

}

int lca(int x,int y)

{

    if(dep[x]<dep[y])

	   swap(x,y);

    for(int i=19;i>=0;i--)

	   x=dep[f[x][i]]>dep[y]?f[x][i]:x;

    if(dep[x]>dep[y])

	    x=f[x][0];

    for(int i=19;i>=0;i--)

	    if(f[x][i]!=f[y][i])

		     x=f[x][i],y=f[y][i];

    return x==y?x:f[x][0];

}

int dis(int x,int y) //求x,y两点的距离

{

	if(!x||!y)

	   return 0;

	int z=lca(x,y);

	    return dep[x]+dep[y]-2*dep[z];}

void merge(fq &now,fq x,fq y)

//将x,y所代表的区间进行合并，结果放到now中

{

    int a,b,c,d,e;

    a=dis(x.x,y.x);//新直径可能为x左点与y左点的距离

	b=dis(x.x,y.y);//新直径可能为x左点与y右点的距离

	c=dis(x.y,y.x);

	d=dis(x.y,y.y);

    e=max(a,max(b,max(c,d)));//取最大值

    if(a==e)

	    now.x=x.x,now.y=y.x,now.sum=a;

	if(b==e)

	    now.x=x.x,now.y=y.y,now.sum=b;

    if(c==e)

	   now.x=x.y,now.y=y.x,now.sum=c;

	if(d==e)

	   now.x=x.y,now.y=y.y,now.sum=d;

    if(x.sum>now.sum)//x区间的直径大于之

	   now.x=x.x,now.y=x.y,now.sum=x.sum;

    if(y.sum>now.sum)//y区间的直径大于之

	   now.x=y.x,now.y=y.y,now.sum=y.sum;

    if(!now.sum)

	   now.x=now.y=0;

}

void build(int now,int l,int r)

{

    if(l==r)

	 {

			t[now].x=t[now].y=p[l];

			return ;

	 }

    int mid=(l+r)>>1;

	build(ls);

	build(rs);

	merge(t[now],t[now<<1],t[now<<1|1]);

}

void get_ans(int now,int l,int r,int x,int y)

//get_ans(1,1,n,1,dfn[u]-1);

//now根结点编号,l,r左右区间

{

    if(x<=l&&r<=y)

	  {

			merge(ans,ans,t[now]);

			return ;

	  }

    int mid=(l+r)>>1;

    if(x<=mid)

	   get_ans(ls,x,y);

    if(y>mid)

	   get_ans(rs,x,y);

}

int main()

{

    scanf("%d%d",&n,&q);

	int u,v;

    for(int i=1;i<n;i++)

	     scanf("%d%d",&u,&v),ins(u,v),ins(v,u);

    dfs(1,0);

	for(int j=1;j<20;j++)

	    for(int i=1;i<=n;i++)

		     f[i][j]=f[f[i][j-1]][j-1];

    build(1,1,n);

    while(q--)

    {

        scanf("%d%d",&u,&v);

        if(v==1||u==1) //去掉的是根结点

		  {

				puts("0");

				continue;

		  }

        ans.sum=ans.x=ans.y=0;

        if(dfn[u]>dfn[v]) //让u进入的时间更小

		   swap(u,v);

        get_ans(1,1,n,1,dfn[u]-1);//从1开始到u进入前的

        get_ans(1,1,n,last[u]+1,dfn[v]-1);//从u离开后v进来之前

        if(last[v]<=last[u])

		//看谁离开的时间更大,从离开后的那个时间到n之一段也要加进来

		    get_ans(1,1,n,last[u]+1,n);

        else

		     get_ans(1,1,n,last[v]+1,n);

        printf("%d\n",ans.sum);

    }

}