매일 1문장 초보영어회화

봄동 영어로 뭐라고 할까? 배추 영어로, 봄동 배추 차이, 달래 영어로

2026.02.09 13:47
조회 스크랩

 

봄동 뜻, 봄동 제철,

봄동 배추 차이, 배추 영어로,

봄동겉절이 영어로, 달래 영어로

 

봄이 되면 식탁에서

자주 등장하는 채소가

바로 봄동입니다.


요즘처럼 제철 식재료에 대한

관심이 높아지면서

봄동 영어로 어떻게 표현하는지,

또 배추나 다른 봄나물과는

어떤 차이가 있는지

궁금해하는 분들도 많아졌습니다.

 

이 글에서는 봄동 영어로를 중심으로

봄동 뜻, 봄동 제철, 봄동 배추 차이,

배추 영어로, 봄동겉절이 영어로,

달래 영어로까지

한 번에 정리해드립니다.

 

 

📃목차

1. 봄동 뜻&봄동 영어로

2. 봄동 제철

 

3. 봄동 배추 차이

 

4. 배추 영어로

 

5. 봄동겉절이 영어로

 

6. 달래 영어로
👉메모리워드 앱 다운 받으러 가기(클릭)

 

 

 

 

1️⃣봄동 뜻&봄동 영어로

alt=봄동-뜻,봄동-제철,봄동-배추-차이,배추-영어로,봄동겉절이-영어로,달래-영어로

 

먼저 봄동 뜻부터 알아보겠습니다.
봄동은 겨울을 지나

이른 봄에 수확하는 배추의 한 종류로,

일반 배추보다 크기가 작고

잎이 단단한 것이 특징입니다.

 

일부에서는 ‘겨울을 지나

봄을 가져오는 채소’로 설명하기도 하지만,

이는 공식적인 어원이라기보다는

봄동의 재배 시기와

계절적 이미지를 바탕으로 한

해석에 가깝습니다.

 

봄동은 한국에서 주로

소비되는 채소이기 때문에

영어권에서 쓰이는 봄동 영어로

고유 명칭은 없습니다.

 

그래서 봄동 영어로는

직역보다는 설명형 표현이 자연스럽습니다.

 

보통 봄동 영어로는

spring cabbage 또는

young napa cabbage harvested
in early spring처럼 표현합니다.

 

상황에 따라 봄동 영어로는

‘봄에 수확한 배추’라는

설명을 덧붙이는 것이 좋습니다.

 

 

👉 봄동 뜻&봄동 영어로 예문

 1. Bomdong is a type of cabbage
harvested in early spring.

→ 봄동은 이른 봄에 수확하는 배추의
한 종류입니다.

 

2. The sweet taste is a key feature
of bomdong.

→ 단맛이 강한 것이 봄동의 특징입니다.

 

3. Bomdong can be described as
spring cabbage in English.

→ 봄동은 영어로 봄배추라고 설명할 수 있습니다.

 

👉 봄동은 ‘봄에 먹는 어린 배추’라고

이해하면 쉽습니다.

 

 

 

2️⃣봄동 제철

alt=봄동-뜻,봄동-제철,봄동-배추-차이,배추-영어로,봄동겉절이-영어로,달래-영어로

 

봄동 제철은 보통
1월부터 3월까지입니다.

특히 2월이 가장 맛있는 시기로

알려져 있는데요. 


겨울을 지나며 서리를 맞은 뒤

수확되기 때문에

이 시기의 봄동은

단맛이 가장 잘 올라옵니다.

 

제철에 즐길수록

맛이 뛰어난 것이

가장 큰 특징입니다.

 

 

👉 봄동 제철 예문

 1. Bomdong is in season from
late winter to early spring.

→ 봄동 제철은 늦겨울부터 이른 봄까지입니다.

 

2. Spring cabbage tastes best during
its peak season.

→ 봄동은 제철에 가장 맛있습니다.

 

 

 

 

3️⃣봄동 배추 차이

alt=봄동-뜻,봄동-제철,봄동-배추-차이,배추-영어로,봄동겉절이-영어로,달래-영어로

 

헷갈리기 쉬운 부분이 바로

봄동과 배추의 차이입니다.


봄동과 일반 배추는

같은 배추 계열이지만

재배 시기와 식감에서 차이가 있습니다.

 

일반 배추는 크고

잎이 부드러운 반면,

봄동은 잎이 작고 단단하며

단맛이 강합니다.

 

 

👉 봄동 배추 차이 예문

 1. Bomdong is smaller and crunchier than
regular cabbage.

→ 봄동은 일반 배추보다 작고 아삭합니다.

 

2. The main difference between bomdong
and cabbage is the harvest time.

→ 봄동 배추 차이의 핵심은 수확 시기입니다.

 

👉 즉, 봄동과 배추의 차이는
수확 시기와 조직감에서
가장 뚜렷하게 나타납니다.

 

 

 

 

4️⃣배추 영어로

alt=봄동-뜻,봄동-제철,봄동-배추-차이,배추-영어로,봄동겉절이-영어로,달래-영어로

 

그렇다면 배추 영어로는

어떻게 말할까요?


일반적으로 배추는

napa cabbage 또는

Chinese cabbage,

Kimchi cabbage라고 합니다.

 

요리 설명이나 식재료 소개에서

이 두 표현이 가장 많이 사용됩니다.

 

 

👉 배추 영어로 예문

1. Kimchi is made from napa cabbage.

→ 김치는 배추로 만듭니다.

 

2. Kimchi cabbage is commonly used in
Korean cuisine.
→ 배추는 한국 요리에 자주 사용됩니다.

 

 

 

 

5️⃣봄동겉절이 영어로

alt=봄동-뜻,봄동-제철,봄동-배추-차이,배추-영어로,봄동겉절이-영어로,달래-영어로

 

봄동겉절이 영어로는

직역된 단어가 없기 때문에

조리 방식 위주로 설명합니다.


보통 fresh spring cabbage salad

또는 seasoned spring cabbage처럼

표현하면 자연스럽습니다.

 

 

👉 봄동겉절이 영어로 예문

1. This is a fresh spring cabbage salad
seasoned with chili paste.

→ 이것은 봄동겉절이입니다.

 

2. Seasoned spring cabbage is popular
in early spring.
→ 봄동겉절이는 이른 봄에 인기가 많습니다.

 

 

 

 

6️⃣달래 영어로

alt=봄동-뜻,봄동-제철,봄동-배추-차이,배추-영어로,봄동겉절이-영어로,달래-영어로

 

봄동과 함께 자주 등장하는

봄나물이 바로 달래입니다.


달래 영어로는

wild chives 또는

Korean wild garlic이라고

설명하는 경우가 많습니다.

 

특히 한식 설명에서는

한국식 봄나물이라는

설명을 함께 덧붙이면

이해하기 쉽습니다.

 

 

👉 달래 영어로 예문

1. Wild chives are commonly used in
Korean spring dishes.

→ 달래는 한국의 봄 요리에 자주 사용됩니다.

 

2. This sauce contains Korean wild garlic.
→ 이 소스에는 달래가 들어갑니다.

 

 

 

 

지금까지 

봄동 영어로를 중심으로

봄동 뜻, 봄동 제철, 봄동 배추 차이,

배추 영어로, 봄동겉절이 영어로,

달래 영어로까지

자세히 살펴봤습니다.

 

정리해보면 봄동 영어로는
하나의 단어로 옮기기보다는
설명형 표현이 가장 자연스럽습니다.

 

영어권에는 봄동과 정확히 일치하는

채소 개념이 없기 때문에,

뜻과 재배 시기를

함께 설명해주는 방식이

실제로 더 잘 전달됩니다.

 

오늘 정리한 봄동 영어로

표현과 예문을 활용하면,

제철 음식 소개나 한식 설명 상황에서도

봄동을 부담 없이 자연스럽게

소개할 수 있을 것입니다.

 

 

함께 보면 좋을 영어 표현들

보쌈 영어로? 족발, 수육·굴 보쌈까지
영어 표현 총정리!(클릭)
김장 영어로? 김장 김치부터 김장 봉투,
수육 등 김장 문화 영어 표현까지 총정리!(클릭)

굴 영어로? | 생굴, 석화 영어로,
겨울 해산물 영어 표현 총정리!(클릭)

 

 

📱유용한 영어 표현,
핸드폰 켤 때마다 배우고 싶다면?
👉메모리워드 앱 다운 받으러 가기(클릭) 

 

 

 

 

🎁 회화왕 이벤트 🎁

 

 

위에 작성된 회화 문장들 중

한 문장 따라쓰고 댓글에 남기기만 해도,

1,500캐시를 드립니다!

(*매일 5명 추첨)

 

 

*당첨자 발표는 2/10 화요일

[이벤트] 게시판에 업로드됩니다.

 

 

 

✅ 참여방법 ✅

 

1️⃣ 오늘의 '매일 1문장 초보영어회화' 예문 중

마음에 드는 예문을 하단 댓글창에 입력

 

2️⃣ 입력 후 등록 버튼 클릭

 

 

<예시>

봄동 영어로 뭐라고 할까? 배추 영어로, 봄동 배추 차이, 달래 영어로

 

이벤트 관련 문의사항은

메모리워드 앱 내 [문의하기]로 부탁드립니다.

1
0
댓글 53
  • Quaint Virtuous Martha
    Bomdong is a type of cabbage
harvested in early spring.
  • Mkt
    Bomdong is a type of cabbage harvested in early spring.
  • 프로필 이미지
    영진왕빠
    The sweet taste is a key feature of bomdong.
  • 프로필 이미지
    안레몬
    Bomdong is a type of cabbage harvested in early spring.
  • 프로필 이미지
    komj5532
    Spring cabbage tastes best during
its peak season.
  • 행복 
    Bomdong can be described as spring cabbage in English.
  • 프로필 이미지
    너란아이
    Bomdong is a type of cabbage harvested in early spring.
  • 프로필 이미지
    lovely J
    Spring cabbage tastes best during its peak season.
  • Dazzling Courteous Scott
    Bonding is a type of cabbage harvested in early spring.
  • 프로필 이미지
    yu
    Bomdong is a type of cabbage harvested in early spring.
  • 파이
    Bomdong is a type of cabbage harvested in early spring.
  • 사라🍭
    Spring cabbage tastes best during its peak season.
  • 프로필 이미지
    꽃향기
    Bomdong is in season form 
late winter to early spring.
  • 프로필 이미지
    바람나무
    Bomdong is a type of cabbage harvested in early spring.
  • Compassionate Adventurous Ezra
    struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|struct group_info init_groups = { .usage = ATOMIC_INIT(2) };  struct group_info *groups_alloc(int gidsetsize){  	struct group_info *group_info;  	int nblocks;  	int i;    	nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  	/* Make sure we always allocate at least one indirect block pointer */  	nblocks = nblocks ? : 1;  	group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  	if (!group_info)  		return NULL;  	group_info->ngroups = gidsetsize;  	group_info->nblocks = nblocks;  	atomic_set(&group_info->usage, 1);    	if (gidsetsize <= NGROUPS_SMALL)  		group_info->blocks[0] = group_info->small_block;  	else {  		for (i = 0; i < nblocks; i++) {  			gid_t *b;  			b = (void *)__get_free_page(GFP_USER);  			if (!b)  				goto out_undo_partial_alloc;  			group_info->blocks[i] = b;  		}  	}  	return group_info;    out_undo_partial_alloc:  	while (--i >= 0) {  		free_page((unsigned lon|
  • Illustrious Fearless Douglas
    Bomdong is a type of cabbage harvested in early spring.
  • Illustrious Fearless Douglas
    The sweet taste is a key feature of bomdong.
  • Illustrious Fearless Douglas
    Bomdong can be described as spring cabbage in English.
  • Illustrious Fearless Douglas
    Bomdong is in season from late winter to early spring.
  • Illustrious Fearless Douglas
    Spring cabbage tastes best during its peak season.