Eric Lee / smarc-ti-linux-kernel

1

/*

1

/*

2

3

*/

3

*/

4

5

#include <linux/config.h>

5

#include <linux/config.h>

6

#include <linux/time.h>

6

#include <linux/time.h>

7

#include <linux/fs.h>

7

#include <linux/fs.h>

8

#include <linux/reiserfs_fs.h>

8

#include <linux/reiserfs_fs.h>

9

#include <linux/reiserfs_acl.h>

9

#include <linux/reiserfs_acl.h>

10

#include <linux/reiserfs_xattr.h>

10

#include <linux/reiserfs_xattr.h>

11

#include <linux/smp_lock.h>

11

#include <linux/smp_lock.h>

12

#include <linux/pagemap.h>

12

#include <linux/pagemap.h>

13

#include <linux/highmem.h>

13

#include <linux/highmem.h>

14

#include <asm/uaccess.h>

14

#include <asm/uaccess.h>

15

#include <asm/unaligned.h>

15

#include <asm/unaligned.h>

16

#include <linux/buffer_head.h>

16

#include <linux/buffer_head.h>

17

#include <linux/mpage.h>

17

#include <linux/mpage.h>

18

#include <linux/writeback.h>

18

#include <linux/writeback.h>

19

#include <linux/quotaops.h>

19

#include <linux/quotaops.h>

20

21

extern int reiserfs_default_io_size; /* default io size devuned in super.c */

21

extern int reiserfs_default_io_size; /* default io size devuned in super.c */

22

23

static int reiserfs_commit_write(struct file *f, struct page *page,

23

static int reiserfs_commit_write(struct file *f, struct page *page,

24

unsigned from, unsigned to);

24

unsigned from, unsigned to);

25

static int reiserfs_prepare_write(struct file *f, struct page *page,

25

static int reiserfs_prepare_write(struct file *f, struct page *page,

26

unsigned from, unsigned to);

26

unsigned from, unsigned to);

27

28

void reiserfs_delete_inode(struct inode *inode)

28

void reiserfs_delete_inode(struct inode *inode)

29

{

29

{

30

/* We need blocks for transaction + (user+group) quota update (possibly delete) */

30

/* We need blocks for transaction + (user+group) quota update (possibly delete) */

31

int jbegin_count =

31

int jbegin_count =

32

JOURNAL_PER_BALANCE_CNT * 2 +

32

JOURNAL_PER_BALANCE_CNT * 2 +

33

2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);

33

2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);

34

struct reiserfs_transaction_handle th;

34

struct reiserfs_transaction_handle th;

35

36

reiserfs_write_lock(inode->i_sb);

36

reiserfs_write_lock(inode->i_sb);

37

38

/* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */

38

/* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */

39

if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */

39

if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */

40

down(&inode->i_sem);

40

down(&inode->i_sem);

41

42

reiserfs_delete_xattrs(inode);

42

reiserfs_delete_xattrs(inode);

43

44

if (journal_begin(&th, inode->i_sb, jbegin_count)) {

44

if (journal_begin(&th, inode->i_sb, jbegin_count)) {

45

up(&inode->i_sem);

45

up(&inode->i_sem);

46

goto out;

46

goto out;

47

}

47

}

48

reiserfs_update_inode_transaction(inode);

48

reiserfs_update_inode_transaction(inode);

49

50

if (reiserfs_delete_object(&th, inode)) {

50

if (reiserfs_delete_object(&th, inode)) {

51

up(&inode->i_sem);

51

up(&inode->i_sem);

52

goto out;

52

goto out;

53

}

53

}

54

55

/* Do quota update inside a transaction for journaled quotas. We must do that

55

/* Do quota update inside a transaction for journaled quotas. We must do that

56

* after delete_object so that quota updates go into the same transaction as

56

* after delete_object so that quota updates go into the same transaction as

57

* stat data deletion */

57

* stat data deletion */

58

DQUOT_FREE_INODE(inode);

58

DQUOT_FREE_INODE(inode);

59

60

if (journal_end(&th, inode->i_sb, jbegin_count)) {

60

if (journal_end(&th, inode->i_sb, jbegin_count)) {

61

up(&inode->i_sem);

61

up(&inode->i_sem);

62

goto out;

62

goto out;

63

}

63

}

64

65

up(&inode->i_sem);

65

up(&inode->i_sem);

66

67

/* all items of file are deleted, so we can remove "save" link */

67

/* all items of file are deleted, so we can remove "save" link */

68

remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything

68

remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything

69

* about an error here */

69

* about an error here */

70

} else {

70

} else {

71

/* no object items are in the tree */

71

/* no object items are in the tree */

72

;

72

;

73

}

73

}

74

out:

74

out:

75

clear_inode(inode); /* note this must go after the journal_end to prevent deadlock */

75

clear_inode(inode); /* note this must go after the journal_end to prevent deadlock */

76

inode->i_blocks = 0;

76

inode->i_blocks = 0;

77

reiserfs_write_unlock(inode->i_sb);

77

reiserfs_write_unlock(inode->i_sb);

78

}

78

}

79

80

static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,

80

static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,

81

__u32 objectid, loff_t offset, int type, int length)

81

__u32 objectid, loff_t offset, int type, int length)

82

{

82

{

83

key->version = version;

83

key->version = version;

84

85

key->on_disk_key.k_dir_id = dirid;

85

key->on_disk_key.k_dir_id = dirid;

86

key->on_disk_key.k_objectid = objectid;

86

key->on_disk_key.k_objectid = objectid;

87

set_cpu_key_k_offset(key, offset);

87

set_cpu_key_k_offset(key, offset);

88

set_cpu_key_k_type(key, type);

88

set_cpu_key_k_type(key, type);

89

key->key_length = length;

89

key->key_length = length;

90

}

90

}

91

92

/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set

92

/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set

93

offset and type of key */

93

offset and type of key */

94

void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,

94

void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,

95

int type, int length)

95

int type, int length)

96

{

96

{

97

_make_cpu_key(key, get_inode_item_key_version(inode),

97

_make_cpu_key(key, get_inode_item_key_version(inode),

98

le32_to_cpu(INODE_PKEY(inode)->k_dir_id),

98

le32_to_cpu(INODE_PKEY(inode)->k_dir_id),

99

le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,

99

le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,

100

length);

100

length);

101

}

101

}

102

103

//

103

//

104

// when key is 0, do not set version and short key

104

// when key is 0, do not set version and short key

105

//

105

//

106

inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,

106

inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,

107

int version,

107

int version,

108

loff_t offset, int type, int length,

108

loff_t offset, int type, int length,

109

int entry_count /*or ih_free_space */ )

109

int entry_count /*or ih_free_space */ )

110

{

110

{

111

if (key) {

111

if (key) {

112

ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);

112

ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);

113

ih->ih_key.k_objectid =

113

ih->ih_key.k_objectid =

114

cpu_to_le32(key->on_disk_key.k_objectid);

114

cpu_to_le32(key->on_disk_key.k_objectid);

115

}

115

}

116

put_ih_version(ih, version);

116

put_ih_version(ih, version);

117

set_le_ih_k_offset(ih, offset);

117

set_le_ih_k_offset(ih, offset);

118

set_le_ih_k_type(ih, type);

118

set_le_ih_k_type(ih, type);

119

put_ih_item_len(ih, length);

119

put_ih_item_len(ih, length);

120

/* set_ih_free_space (ih, 0); */

120

/* set_ih_free_space (ih, 0); */

121

// for directory items it is entry count, for directs and stat

121

// for directory items it is entry count, for directs and stat

122

// datas - 0xffff, for indirects - 0

122

// datas - 0xffff, for indirects - 0

123

put_ih_entry_count(ih, entry_count);

123

put_ih_entry_count(ih, entry_count);

124

}

124

}

125

126

//

126

//

127

// FIXME: we might cache recently accessed indirect item

127

// FIXME: we might cache recently accessed indirect item

128

129

// Ugh. Not too eager for that....

129

// Ugh. Not too eager for that....

130

// I cut the code until such time as I see a convincing argument (benchmark).

130

// I cut the code until such time as I see a convincing argument (benchmark).

131

// I don't want a bloated inode struct..., and I don't like code complexity....

131

// I don't want a bloated inode struct..., and I don't like code complexity....

132

133

/* cutting the code is fine, since it really isn't in use yet and is easy

133

/* cutting the code is fine, since it really isn't in use yet and is easy

134

** to add back in. But, Vladimir has a really good idea here. Think

134

** to add back in. But, Vladimir has a really good idea here. Think

135

** about what happens for reading a file. For each page,

135

** about what happens for reading a file. For each page,

136

** The VFS layer calls reiserfs_readpage, who searches the tree to find

136

** The VFS layer calls reiserfs_readpage, who searches the tree to find

137

** an indirect item. This indirect item has X number of pointers, where

137

** an indirect item. This indirect item has X number of pointers, where

138

** X is a big number if we've done the block allocation right. But,

138

** X is a big number if we've done the block allocation right. But,

139

** we only use one or two of these pointers during each call to readpage,

139

** we only use one or two of these pointers during each call to readpage,

140

** needlessly researching again later on.

140

** needlessly researching again later on.

141

**

141

**

142

** The size of the cache could be dynamic based on the size of the file.

142

** The size of the cache could be dynamic based on the size of the file.

143

**

143

**

144

** I'd also like to see us cache the location the stat data item, since

144

** I'd also like to see us cache the location the stat data item, since

145

** we are needlessly researching for that frequently.

145

** we are needlessly researching for that frequently.

146

**

146

**

147

** --chris

147

** --chris

148

*/

148

*/

149

150

/* If this page has a file tail in it, and

150

/* If this page has a file tail in it, and

151

** it was read in by get_block_create_0, the page data is valid,

151

** it was read in by get_block_create_0, the page data is valid,

152

** but tail is still sitting in a direct item, and we can't write to

152

** but tail is still sitting in a direct item, and we can't write to

153

** it. So, look through this page, and check all the mapped buffers

153

** it. So, look through this page, and check all the mapped buffers

154

** to make sure they have valid block numbers. Any that don't need

154

** to make sure they have valid block numbers. Any that don't need

155

** to be unmapped, so that block_prepare_write will correctly call

155

** to be unmapped, so that block_prepare_write will correctly call

156

** reiserfs_get_block to convert the tail into an unformatted node

156

** reiserfs_get_block to convert the tail into an unformatted node

157

*/

157

*/

158

static inline void fix_tail_page_for_writing(struct page *page)

158

static inline void fix_tail_page_for_writing(struct page *page)

159

{

159

{

160

struct buffer_head *head, *next, *bh;

160

struct buffer_head *head, *next, *bh;

161

162

if (page && page_has_buffers(page)) {

162

if (page && page_has_buffers(page)) {

163

head = page_buffers(page);

163

head = page_buffers(page);

164

bh = head;

164

bh = head;

165

do {

165

do {

166

next = bh->b_this_page;

166

next = bh->b_this_page;

167

if (buffer_mapped(bh) && bh->b_blocknr == 0) {

167

if (buffer_mapped(bh) && bh->b_blocknr == 0) {

168

reiserfs_unmap_buffer(bh);

168

reiserfs_unmap_buffer(bh);

169

}

169

}

170

bh = next;

170

bh = next;

171

} while (bh != head);

171

} while (bh != head);

172

}

172

}

173

}

173

}

174

175

/* reiserfs_get_block does not need to allocate a block only if it has been

175

/* reiserfs_get_block does not need to allocate a block only if it has been

176

done already or non-hole position has been found in the indirect item */

176

done already or non-hole position has been found in the indirect item */

177

static inline int allocation_needed(int retval, b_blocknr_t allocated,

177

static inline int allocation_needed(int retval, b_blocknr_t allocated,

178

struct item_head *ih,

178

struct item_head *ih,

179

__le32 * item, int pos_in_item)

179

__le32 * item, int pos_in_item)

180

{

180

{

181

if (allocated)

181

if (allocated)

182

return 0;

182

return 0;

183

if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&

183

if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&

184

get_block_num(item, pos_in_item))

184

get_block_num(item, pos_in_item))

185

return 0;

185

return 0;

186

return 1;

186

return 1;

187

}

187

}

188

189

static inline int indirect_item_found(int retval, struct item_head *ih)

189

static inline int indirect_item_found(int retval, struct item_head *ih)

190

{

190

{

191

return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);

191

return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);

192

}

192

}

193

194

static inline void set_block_dev_mapped(struct buffer_head *bh,

194

static inline void set_block_dev_mapped(struct buffer_head *bh,

195

b_blocknr_t block, struct inode *inode)

195

b_blocknr_t block, struct inode *inode)

196

{

196

{

197

map_bh(bh, inode->i_sb, block);

197

map_bh(bh, inode->i_sb, block);

198

}

198

}

199

200

//

200

//

201

// files which were created in the earlier version can not be longer,

201

// files which were created in the earlier version can not be longer,

202

// than 2 gb

202

// than 2 gb

203

//

203

//

204

static int file_capable(struct inode *inode, long block)

204

static int file_capable(struct inode *inode, long block)

205

{

205

{

206

if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 || // it is new file.

206

if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 || // it is new file.

207

block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb

207

block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb

208

return 1;

208

return 1;

209

210

return 0;

210

return 0;

211

}

211

}

212

213

/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,

213

/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,

214

struct inode *inode, struct path *path)

214

struct inode *inode, struct path *path)

215

{

215

{

216

struct super_block *s = th->t_super;

216

struct super_block *s = th->t_super;

217

int len = th->t_blocks_allocated;

217

int len = th->t_blocks_allocated;

218

int err;

218

int err;

219

220

BUG_ON(!th->t_trans_id);

220

BUG_ON(!th->t_trans_id);

221

BUG_ON(!th->t_refcount);

221

BUG_ON(!th->t_refcount);

222

223

/* we cannot restart while nested */

223

/* we cannot restart while nested */

224

if (th->t_refcount > 1) {

224

if (th->t_refcount > 1) {

225

return 0;

225

return 0;

226

}

226

}

227

pathrelse(path);

227

pathrelse(path);

228

reiserfs_update_sd(th, inode);

228

reiserfs_update_sd(th, inode);

229

err = journal_end(th, s, len);

229

err = journal_end(th, s, len);

230

if (!err) {

230

if (!err) {

231

err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);

231

err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);

232

if (!err)

232

if (!err)

233

reiserfs_update_inode_transaction(inode);

233

reiserfs_update_inode_transaction(inode);

234

}

234

}

235

return err;

235

return err;

236

}

236

}

237

238

// it is called by get_block when create == 0. Returns block number

238

// it is called by get_block when create == 0. Returns block number

239

// for 'block'-th logical block of file. When it hits direct item it

239

// for 'block'-th logical block of file. When it hits direct item it

240

// returns 0 (being called from bmap) or read direct item into piece

240

// returns 0 (being called from bmap) or read direct item into piece

241

// of page (bh_result)

241

// of page (bh_result)

242

243

// Please improve the english/clarity in the comment above, as it is

243

// Please improve the english/clarity in the comment above, as it is

244

// hard to understand.

244

// hard to understand.

245

246

static int _get_block_create_0(struct inode *inode, long block,

246

static int _get_block_create_0(struct inode *inode, long block,

247

struct buffer_head *bh_result, int args)

247

struct buffer_head *bh_result, int args)

248

{

248

{

249

INITIALIZE_PATH(path);

249

INITIALIZE_PATH(path);

250

struct cpu_key key;

250

struct cpu_key key;

251

struct buffer_head *bh;

251

struct buffer_head *bh;

252

struct item_head *ih, tmp_ih;

252

struct item_head *ih, tmp_ih;

253

int fs_gen;

253

int fs_gen;

254

int blocknr;

254

int blocknr;

255

char *p = NULL;

255

char *p = NULL;

256

int chars;

256

int chars;

257

int ret;

257

int ret;

258

int result;

258

int result;

259

int done = 0;

259

int done = 0;

260

unsigned long offset;

260

unsigned long offset;

261

262

// prepare the key to look for the 'block'-th block of file

262

// prepare the key to look for the 'block'-th block of file

263

make_cpu_key(&key, inode,

263

make_cpu_key(&key, inode,

264

(loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,

264

(loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,

265

3);

265

3);

266

267

research:

267

research:

268

result = search_for_position_by_key(inode->i_sb, &key, &path);

268

result = search_for_position_by_key(inode->i_sb, &key, &path);

269

if (result != POSITION_FOUND) {

269

if (result != POSITION_FOUND) {

270

pathrelse(&path);

270

pathrelse(&path);

271

if (p)

271

if (p)

272

kunmap(bh_result->b_page);

272

kunmap(bh_result->b_page);

273

if (result == IO_ERROR)

273

if (result == IO_ERROR)

274

return -EIO;

274

return -EIO;

275

// We do not return -ENOENT if there is a hole but page is uptodate, because it means

275

// We do not return -ENOENT if there is a hole but page is uptodate, because it means

276

// That there is some MMAPED data associated with it that is yet to be written to disk.

276

// That there is some MMAPED data associated with it that is yet to be written to disk.

277

if ((args & GET_BLOCK_NO_HOLE)

277

if ((args & GET_BLOCK_NO_HOLE)

278

&& !PageUptodate(bh_result->b_page)) {

278

&& !PageUptodate(bh_result->b_page)) {

279

return -ENOENT;

279

return -ENOENT;

280

}

280

}

281

return 0;

281

return 0;

282

}

282

}

283

//

283

//

284

bh = get_last_bh(&path);

284

bh = get_last_bh(&path);

285

ih = get_ih(&path);

285

ih = get_ih(&path);

286

if (is_indirect_le_ih(ih)) {

286

if (is_indirect_le_ih(ih)) {

287

__le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);

287

__le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);

288

289

/* FIXME: here we could cache indirect item or part of it in

289

/* FIXME: here we could cache indirect item or part of it in

290

the inode to avoid search_by_key in case of subsequent

290

the inode to avoid search_by_key in case of subsequent

291

access to file */

291

access to file */

292

blocknr = get_block_num(ind_item, path.pos_in_item);

292

blocknr = get_block_num(ind_item, path.pos_in_item);

293

ret = 0;

293

ret = 0;

294

if (blocknr) {

294

if (blocknr) {

295

map_bh(bh_result, inode->i_sb, blocknr);

295

map_bh(bh_result, inode->i_sb, blocknr);

296

if (path.pos_in_item ==

296

if (path.pos_in_item ==

297

((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {

297

((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {

298

set_buffer_boundary(bh_result);

298

set_buffer_boundary(bh_result);

299

}

299

}

300

} else

300

} else

301

// We do not return -ENOENT if there is a hole but page is uptodate, because it means

301

// We do not return -ENOENT if there is a hole but page is uptodate, because it means

302

// That there is some MMAPED data associated with it that is yet to be written to disk.

302

// That there is some MMAPED data associated with it that is yet to be written to disk.

303

if ((args & GET_BLOCK_NO_HOLE)

303

if ((args & GET_BLOCK_NO_HOLE)

304

&& !PageUptodate(bh_result->b_page)) {

304

&& !PageUptodate(bh_result->b_page)) {

305

ret = -ENOENT;

305

ret = -ENOENT;

306

}

306

}

307

308

pathrelse(&path);

308

pathrelse(&path);

309

if (p)

309

if (p)

310

kunmap(bh_result->b_page);

310

kunmap(bh_result->b_page);

311

return ret;

311

return ret;

312

}

312

}

313

// requested data are in direct item(s)

313

// requested data are in direct item(s)

314

if (!(args & GET_BLOCK_READ_DIRECT)) {

314

if (!(args & GET_BLOCK_READ_DIRECT)) {

315

// we are called by bmap. FIXME: we can not map block of file

315

// we are called by bmap. FIXME: we can not map block of file

316

// when it is stored in direct item(s)

316

// when it is stored in direct item(s)

317

pathrelse(&path);

317

pathrelse(&path);

318

if (p)

318

if (p)

319

kunmap(bh_result->b_page);

319

kunmap(bh_result->b_page);

320

return -ENOENT;

320

return -ENOENT;

321

}

321

}

322

323

/* if we've got a direct item, and the buffer or page was uptodate,

323

/* if we've got a direct item, and the buffer or page was uptodate,

324

** we don't want to pull data off disk again. skip to the

324

** we don't want to pull data off disk again. skip to the

325

** end, where we map the buffer and return

325

** end, where we map the buffer and return

326

*/

326

*/

327

if (buffer_uptodate(bh_result)) {

327

if (buffer_uptodate(bh_result)) {

328

goto finished;

328

goto finished;

329

} else

329

} else

330

/*

330

/*

331

** grab_tail_page can trigger calls to reiserfs_get_block on up to date

331

** grab_tail_page can trigger calls to reiserfs_get_block on up to date

332

** pages without any buffers. If the page is up to date, we don't want

332

** pages without any buffers. If the page is up to date, we don't want

333

** read old data off disk. Set the up to date bit on the buffer instead

333

** read old data off disk. Set the up to date bit on the buffer instead

334

** and jump to the end

334

** and jump to the end

335

*/

335

*/

336

if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {

336

if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {

337

set_buffer_uptodate(bh_result);

337

set_buffer_uptodate(bh_result);

338

goto finished;

338

goto finished;

339

}

339

}

340

// read file tail into part of page

340

// read file tail into part of page

341

offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);

341

offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);

342

fs_gen = get_generation(inode->i_sb);

342

fs_gen = get_generation(inode->i_sb);

343

copy_item_head(&tmp_ih, ih);

343

copy_item_head(&tmp_ih, ih);

344

345

/* we only want to kmap if we are reading the tail into the page.

345

/* we only want to kmap if we are reading the tail into the page.

346

** this is not the common case, so we don't kmap until we are

346

** this is not the common case, so we don't kmap until we are

347

** sure we need to. But, this means the item might move if

347

** sure we need to. But, this means the item might move if

348

** kmap schedules

348

** kmap schedules

349

*/

349

*/

350

if (!p) {

350

if (!p) {

351

p = (char *)kmap(bh_result->b_page);

351

p = (char *)kmap(bh_result->b_page);

352

if (fs_changed(fs_gen, inode->i_sb)

352

if (fs_changed(fs_gen, inode->i_sb)

353

&& item_moved(&tmp_ih, &path)) {

353

&& item_moved(&tmp_ih, &path)) {

354

goto research;

354

goto research;

355

}

355

}

356

}

356

}

357

p += offset;

357

p += offset;

358

memset(p, 0, inode->i_sb->s_blocksize);

358

memset(p, 0, inode->i_sb->s_blocksize);

359

do {

359

do {

360

if (!is_direct_le_ih(ih)) {

360

if (!is_direct_le_ih(ih)) {

361

BUG();

361

BUG();

362

}

362

}

363

/* make sure we don't read more bytes than actually exist in

363

/* make sure we don't read more bytes than actually exist in

364

** the file. This can happen in odd cases where i_size isn't

364

** the file. This can happen in odd cases where i_size isn't

365

** correct, and when direct item padding results in a few

365

** correct, and when direct item padding results in a few

366

** extra bytes at the end of the direct item

366

** extra bytes at the end of the direct item

367

*/

367

*/

368

if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)

368

if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)

369

break;

369

break;

370

if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {

370

if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {

371

chars =

371

chars =

372

inode->i_size - (le_ih_k_offset(ih) - 1) -

372

inode->i_size - (le_ih_k_offset(ih) - 1) -

373

path.pos_in_item;

373

path.pos_in_item;

374

done = 1;

374

done = 1;

375

} else {

375

} else {

376

chars = ih_item_len(ih) - path.pos_in_item;

376

chars = ih_item_len(ih) - path.pos_in_item;

377

}

377

}

378

memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);

378

memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);

379

380

if (done)

380

if (done)

381

break;

381

break;

382

383

p += chars;

383

p += chars;

384

385

if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))

385

if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))

386

// we done, if read direct item is not the last item of

386

// we done, if read direct item is not the last item of

387

// node FIXME: we could try to check right delimiting key

387

// node FIXME: we could try to check right delimiting key

388

// to see whether direct item continues in the right

388

// to see whether direct item continues in the right

389

// neighbor or rely on i_size

389

// neighbor or rely on i_size

390

break;

390

break;

391

392

// update key to look for the next piece

392

// update key to look for the next piece

393

set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);

393

set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);

394

result = search_for_position_by_key(inode->i_sb, &key, &path);

394

result = search_for_position_by_key(inode->i_sb, &key, &path);

395

if (result != POSITION_FOUND)

395

if (result != POSITION_FOUND)

396

// i/o error most likely

396

// i/o error most likely

397

break;

397

break;

398

bh = get_last_bh(&path);

398

bh = get_last_bh(&path);

399

ih = get_ih(&path);

399

ih = get_ih(&path);

400

} while (1);

400

} while (1);

401

402

flush_dcache_page(bh_result->b_page);

402

flush_dcache_page(bh_result->b_page);

403

kunmap(bh_result->b_page);

403

kunmap(bh_result->b_page);

404

405

finished:

405

finished:

406

pathrelse(&path);

406

pathrelse(&path);

407

408

if (result == IO_ERROR)

408

if (result == IO_ERROR)

409

return -EIO;

409

return -EIO;

410

411

/* this buffer has valid data, but isn't valid for io. mapping it to

411

/* this buffer has valid data, but isn't valid for io. mapping it to

412

* block #0 tells the rest of reiserfs it just has a tail in it

412

* block #0 tells the rest of reiserfs it just has a tail in it

413

*/

413

*/

414

map_bh(bh_result, inode->i_sb, 0);

414

map_bh(bh_result, inode->i_sb, 0);

415

set_buffer_uptodate(bh_result);

415

set_buffer_uptodate(bh_result);

416

return 0;

416

return 0;

417

}

417

}

418

419

// this is called to create file map. So, _get_block_create_0 will not

419

// this is called to create file map. So, _get_block_create_0 will not

420

// read direct item

420

// read direct item

421

static int reiserfs_bmap(struct inode *inode, sector_t block,

421

static int reiserfs_bmap(struct inode *inode, sector_t block,

422

struct buffer_head *bh_result, int create)

422

struct buffer_head *bh_result, int create)

423

{

423

{

424

if (!file_capable(inode, block))

424

if (!file_capable(inode, block))

425

return -EFBIG;

425

return -EFBIG;

426

427

reiserfs_write_lock(inode->i_sb);

427

reiserfs_write_lock(inode->i_sb);

428

/* do not read the direct item */

428

/* do not read the direct item */

429

_get_block_create_0(inode, block, bh_result, 0);

429

_get_block_create_0(inode, block, bh_result, 0);

430

reiserfs_write_unlock(inode->i_sb);

430

reiserfs_write_unlock(inode->i_sb);

431

return 0;

431

return 0;

432

}

432

}

433

434

/* special version of get_block that is only used by grab_tail_page right

434

/* special version of get_block that is only used by grab_tail_page right

435

** now. It is sent to block_prepare_write, and when you try to get a

435

** now. It is sent to block_prepare_write, and when you try to get a

436

** block past the end of the file (or a block from a hole) it returns

436

** block past the end of the file (or a block from a hole) it returns

437

** -ENOENT instead of a valid buffer. block_prepare_write expects to

437

** -ENOENT instead of a valid buffer. block_prepare_write expects to

438

** be able to do i/o on the buffers returned, unless an error value

438

** be able to do i/o on the buffers returned, unless an error value

439

** is also returned.

439

** is also returned.

440

**

440

**

441

** So, this allows block_prepare_write to be used for reading a single block

441

** So, this allows block_prepare_write to be used for reading a single block

442

** in a page. Where it does not produce a valid page for holes, or past the

442

** in a page. Where it does not produce a valid page for holes, or past the

443

** end of the file. This turns out to be exactly what we need for reading

443

** end of the file. This turns out to be exactly what we need for reading

444

** tails for conversion.

444

** tails for conversion.

445

**

445

**

446

** The point of the wrapper is forcing a certain value for create, even

446

** The point of the wrapper is forcing a certain value for create, even

447

** though the VFS layer is calling this function with create==1. If you

447

** though the VFS layer is calling this function with create==1. If you

448

** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,

448

** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,

449

** don't use this function.

449

** don't use this function.

450

*/

450

*/

451

static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,

451

static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,

452

struct buffer_head *bh_result,

452

struct buffer_head *bh_result,

453

int create)

453

int create)

454

{

454

{

455

return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);

455

return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);

456

}

456

}

457

458

/* This is special helper for reiserfs_get_block in case we are executing

458

/* This is special helper for reiserfs_get_block in case we are executing

459

direct_IO request. */

459

direct_IO request. */

460

static int reiserfs_get_blocks_direct_io(struct inode *inode,

460

static int reiserfs_get_blocks_direct_io(struct inode *inode,

461

sector_t iblock,

461

sector_t iblock,

462

unsigned long max_blocks,

462

unsigned long max_blocks,

463

struct buffer_head *bh_result,

463

struct buffer_head *bh_result,

464

int create)

464

int create)

465

{

465

{

466

int ret;

466

int ret;

467

468

bh_result->b_page = NULL;

468

bh_result->b_page = NULL;

469

470

/* We set the b_size before reiserfs_get_block call since it is

470

/* We set the b_size before reiserfs_get_block call since it is

471

referenced in convert_tail_for_hole() that may be called from

471

referenced in convert_tail_for_hole() that may be called from

472

reiserfs_get_block() */

472

reiserfs_get_block() */

473

bh_result->b_size = (1 << inode->i_blkbits);

473

bh_result->b_size = (1 << inode->i_blkbits);

474

475

ret = reiserfs_get_block(inode, iblock, bh_result,

475

ret = reiserfs_get_block(inode, iblock, bh_result,

476

create | GET_BLOCK_NO_DANGLE);

476

create | GET_BLOCK_NO_DANGLE);

477

if (ret)

477

if (ret)

478

goto out;

478

goto out;

479

480

/* don't allow direct io onto tail pages */

480

/* don't allow direct io onto tail pages */

481

if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {

481

if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {

482

/* make sure future calls to the direct io funcs for this offset

482

/* make sure future calls to the direct io funcs for this offset

483

** in the file fail by unmapping the buffer

483

** in the file fail by unmapping the buffer

484

*/

484

*/

485

clear_buffer_mapped(bh_result);

485

clear_buffer_mapped(bh_result);

486

ret = -EINVAL;

486

ret = -EINVAL;

487

}

487

}

488

/* Possible unpacked tail. Flush the data before pages have

488

/* Possible unpacked tail. Flush the data before pages have

489

disappeared */

489

disappeared */

490

if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {

490

if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {

491

int err;

491

int err;

492

lock_kernel();

492

lock_kernel();

493

err = reiserfs_commit_for_inode(inode);

493

err = reiserfs_commit_for_inode(inode);

494

REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;

494

REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;

495

unlock_kernel();

495

unlock_kernel();

496

if (err < 0)

496

if (err < 0)

497

ret = err;

497

ret = err;

498

}

498

}

499

out:

499

out:

500

return ret;

500

return ret;

501

}

501

}

502

503

/*

503

/*

504

** helper function for when reiserfs_get_block is called for a hole

504

** helper function for when reiserfs_get_block is called for a hole

505

** but the file tail is still in a direct item

505

** but the file tail is still in a direct item

506

** bh_result is the buffer head for the hole

506

** bh_result is the buffer head for the hole

507

** tail_offset is the offset of the start of the tail in the file

507

** tail_offset is the offset of the start of the tail in the file

508

**

508

**

509

** This calls prepare_write, which will start a new transaction

509

** This calls prepare_write, which will start a new transaction

510

** you should not be in a transaction, or have any paths held when you

510

** you should not be in a transaction, or have any paths held when you

511

** call this.

511

** call this.

512

*/

512

*/

513

static int convert_tail_for_hole(struct inode *inode,

513

static int convert_tail_for_hole(struct inode *inode,

514

struct buffer_head *bh_result,

514

struct buffer_head *bh_result,

515

loff_t tail_offset)

515

loff_t tail_offset)

516

{

516

{

517

unsigned long index;

517

unsigned long index;

518

unsigned long tail_end;

518

unsigned long tail_end;

519

unsigned long tail_start;

519

unsigned long tail_start;

520

struct page *tail_page;

520

struct page *tail_page;

521

struct page *hole_page = bh_result->b_page;

521

struct page *hole_page = bh_result->b_page;

522

int retval = 0;

522

int retval = 0;

523

524

if ((tail_offset & (bh_result->b_size - 1)) != 1)

524

if ((tail_offset & (bh_result->b_size - 1)) != 1)

525

return -EIO;

525

return -EIO;

526

527

/* always try to read until the end of the block */

527

/* always try to read until the end of the block */

528

tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);

528

tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);

529

tail_end = (tail_start | (bh_result->b_size - 1)) + 1;

529

tail_end = (tail_start | (bh_result->b_size - 1)) + 1;

530

531

index = tail_offset >> PAGE_CACHE_SHIFT;

531

index = tail_offset >> PAGE_CACHE_SHIFT;

532

/* hole_page can be zero in case of direct_io, we are sure

532

/* hole_page can be zero in case of direct_io, we are sure

533

that we cannot get here if we write with O_DIRECT into

533

that we cannot get here if we write with O_DIRECT into

534

tail page */

534

tail page */

535

if (!hole_page || index != hole_page->index) {

535

if (!hole_page || index != hole_page->index) {

536

tail_page = grab_cache_page(inode->i_mapping, index);

536

tail_page = grab_cache_page(inode->i_mapping, index);

537

retval = -ENOMEM;

537

retval = -ENOMEM;

538

if (!tail_page) {

538

if (!tail_page) {

539

goto out;

539

goto out;

540

}

540

}

541

} else {

541

} else {

542

tail_page = hole_page;

542

tail_page = hole_page;

543

}

543

}

544

545

/* we don't have to make sure the conversion did not happen while

545

/* we don't have to make sure the conversion did not happen while

546

** we were locking the page because anyone that could convert

546

** we were locking the page because anyone that could convert

547

** must first take i_sem.

547

** must first take i_sem.

548

**

548

**

549

** We must fix the tail page for writing because it might have buffers

549

** We must fix the tail page for writing because it might have buffers

550

** that are mapped, but have a block number of 0. This indicates tail

550

** that are mapped, but have a block number of 0. This indicates tail

551

** data that has been read directly into the page, and block_prepare_write

551

** data that has been read directly into the page, and block_prepare_write

552

** won't trigger a get_block in this case.

552

** won't trigger a get_block in this case.

553

*/

553

*/

554

fix_tail_page_for_writing(tail_page);

554

fix_tail_page_for_writing(tail_page);

555

retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);

555

retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);

556

if (retval)

556

if (retval)

557

goto unlock;

557

goto unlock;

558

559

/* tail conversion might change the data in the page */

559

/* tail conversion might change the data in the page */

560

flush_dcache_page(tail_page);

560

flush_dcache_page(tail_page);

561

562

retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);

562

retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);

563

564

unlock:

564

unlock:

565

if (tail_page != hole_page) {

565

if (tail_page != hole_page) {

566

unlock_page(tail_page);

566

unlock_page(tail_page);

567

page_cache_release(tail_page);

567

page_cache_release(tail_page);

568

}

568

}

569

out:

569

out:

570

return retval;

570

return retval;

571

}

571

}

572

573

static inline int _allocate_block(struct reiserfs_transaction_handle *th,

573

static inline int _allocate_block(struct reiserfs_transaction_handle *th,

574

long block,

574

long block,

575

struct inode *inode,

575

struct inode *inode,

576

b_blocknr_t * allocated_block_nr,

576

b_blocknr_t * allocated_block_nr,

577

struct path *path, int flags)

577

struct path *path, int flags)

578

{

578

{

579

BUG_ON(!th->t_trans_id);

579

BUG_ON(!th->t_trans_id);

580

581

#ifdef REISERFS_PREALLOCATE

581

#ifdef REISERFS_PREALLOCATE

582

if (!(flags & GET_BLOCK_NO_ISEM)) {

582

if (!(flags & GET_BLOCK_NO_ISEM)) {

583

return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,

583

return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,

584

path, block);

584

path, block);

585

}

585

}

586

#endif

586

#endif

587

return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,

587

return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,

588

block);

588

block);

589

}

589

}

590

591

int reiserfs_get_block(struct inode *inode, sector_t block,

591

int reiserfs_get_block(struct inode *inode, sector_t block,

592

struct buffer_head *bh_result, int create)

592

struct buffer_head *bh_result, int create)

593

{

593

{

594

int repeat, retval = 0;

594

int repeat, retval = 0;

595

b_blocknr_t allocated_block_nr = 0; // b_blocknr_t is (unsigned) 32 bit int

595

b_blocknr_t allocated_block_nr = 0; // b_blocknr_t is (unsigned) 32 bit int

596

INITIALIZE_PATH(path);

596

INITIALIZE_PATH(path);

597

int pos_in_item;

597

int pos_in_item;

598

struct cpu_key key;

598

struct cpu_key key;

599

struct buffer_head *bh, *unbh = NULL;

599

struct buffer_head *bh, *unbh = NULL;

600

struct item_head *ih, tmp_ih;

600

struct item_head *ih, tmp_ih;

601

__le32 *item;

601

__le32 *item;

602

int done;

602

int done;

603

int fs_gen;

603

int fs_gen;

604

struct reiserfs_transaction_handle *th = NULL;

604

struct reiserfs_transaction_handle *th = NULL;

605

/* space reserved in transaction batch:

605

/* space reserved in transaction batch:

606

. 3 balancings in direct->indirect conversion

606

. 3 balancings in direct->indirect conversion

607

. 1 block involved into reiserfs_update_sd()

607

. 1 block involved into reiserfs_update_sd()

608

XXX in practically impossible worst case direct2indirect()

608

XXX in practically impossible worst case direct2indirect()

609

can incur (much) more than 3 balancings.

609

can incur (much) more than 3 balancings.

610

quota update for user, group */

610

quota update for user, group */

611

int jbegin_count =

611

int jbegin_count =

612

JOURNAL_PER_BALANCE_CNT * 3 + 1 +

612

JOURNAL_PER_BALANCE_CNT * 3 + 1 +

613

2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);

613

2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);

614

int version;

614

int version;

615

int dangle = 1;

615

int dangle = 1;

616

loff_t new_offset =

616

loff_t new_offset =

617

(((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;

617

(((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;

618

619

/* bad.... */

619

/* bad.... */

620

reiserfs_write_lock(inode->i_sb);

620

reiserfs_write_lock(inode->i_sb);

621

version = get_inode_item_key_version(inode);

621

version = get_inode_item_key_version(inode);

622

623

if (block < 0) {

623

if (block < 0) {

624

reiserfs_write_unlock(inode->i_sb);

624

reiserfs_write_unlock(inode->i_sb);

625

return -EIO;

625

return -EIO;

626

}

626

}

627

628

if (!file_capable(inode, block)) {

628

if (!file_capable(inode, block)) {

629

reiserfs_write_unlock(inode->i_sb);

629

reiserfs_write_unlock(inode->i_sb);

630

return -EFBIG;

630

return -EFBIG;

631

}

631

}

632

633

/* if !create, we aren't changing the FS, so we don't need to

633

/* if !create, we aren't changing the FS, so we don't need to

634

** log anything, so we don't need to start a transaction

634

** log anything, so we don't need to start a transaction

635

*/

635

*/

636

if (!(create & GET_BLOCK_CREATE)) {

636

if (!(create & GET_BLOCK_CREATE)) {

637

int ret;

637

int ret;

638

/* find number of block-th logical block of the file */

638

/* find number of block-th logical block of the file */

639

ret = _get_block_create_0(inode, block, bh_result,

639

ret = _get_block_create_0(inode, block, bh_result,

640

create | GET_BLOCK_READ_DIRECT);

640

create | GET_BLOCK_READ_DIRECT);

641

reiserfs_write_unlock(inode->i_sb);

641

reiserfs_write_unlock(inode->i_sb);

642

return ret;

642

return ret;

643

}

643

}

644

/*

644

/*

645

* if we're already in a transaction, make sure to close

645

* if we're already in a transaction, make sure to close

646

* any new transactions we start in this func

646

* any new transactions we start in this func

647

*/

647

*/

648

if ((create & GET_BLOCK_NO_DANGLE) ||

648

if ((create & GET_BLOCK_NO_DANGLE) ||

649

reiserfs_transaction_running(inode->i_sb))

649

reiserfs_transaction_running(inode->i_sb))

650

dangle = 0;

650

dangle = 0;

651

652

/* If file is of such a size, that it might have a tail and tails are enabled

652

/* If file is of such a size, that it might have a tail and tails are enabled

653

** we should mark it as possibly needing tail packing on close

653

** we should mark it as possibly needing tail packing on close

654

*/

654

*/

655

if ((have_large_tails(inode->i_sb)

655

if ((have_large_tails(inode->i_sb)

656

&& inode->i_size < i_block_size(inode) * 4)

656

&& inode->i_size < i_block_size(inode) * 4)

657

|| (have_small_tails(inode->i_sb)

657

|| (have_small_tails(inode->i_sb)

658

&& inode->i_size < i_block_size(inode)))

658

&& inode->i_size < i_block_size(inode)))

659

REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;

659

REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;

660

661

/* set the key of the first byte in the 'block'-th block of file */

661

/* set the key of the first byte in the 'block'-th block of file */

662

make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );

662

make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );

663

if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {

663

if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {

664

start_trans:

664

start_trans:

665

th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);

665

th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);

666

if (!th) {

666

if (!th) {

667

retval = -ENOMEM;

667

retval = -ENOMEM;

668

goto failure;

668

goto failure;

669

}

669

}

670

reiserfs_update_inode_transaction(inode);

670

reiserfs_update_inode_transaction(inode);

671

}

671

}

672

research:

672

research:

673

674

retval = search_for_position_by_key(inode->i_sb, &key, &path);

674

retval = search_for_position_by_key(inode->i_sb, &key, &path);

675

if (retval == IO_ERROR) {

675

if (retval == IO_ERROR) {

676

retval = -EIO;

676

retval = -EIO;

677

goto failure;

677

goto failure;

678

}

678

}

679

680

bh = get_last_bh(&path);

680

bh = get_last_bh(&path);

681

ih = get_ih(&path);

681

ih = get_ih(&path);

682

item = get_item(&path);

682

item = get_item(&path);

683

pos_in_item = path.pos_in_item;

683

pos_in_item = path.pos_in_item;

684

685

fs_gen = get_generation(inode->i_sb);

685

fs_gen = get_generation(inode->i_sb);

686

copy_item_head(&tmp_ih, ih);

686

copy_item_head(&tmp_ih, ih);

687

688

if (allocation_needed

688

if (allocation_needed

689

(retval, allocated_block_nr, ih, item, pos_in_item)) {

689

(retval, allocated_block_nr, ih, item, pos_in_item)) {

690

/* we have to allocate block for the unformatted node */

690

/* we have to allocate block for the unformatted node */

691

if (!th) {

691

if (!th) {

692

pathrelse(&path);

692

pathrelse(&path);

693

goto start_trans;

693

goto start_trans;

694

}

694

}

695

696

repeat =

696

repeat =

697

_allocate_block(th, block, inode, &allocated_block_nr,

697

_allocate_block(th, block, inode, &allocated_block_nr,

698

&path, create);

698

&path, create);

699

700

if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {

700

if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {

701

/* restart the transaction to give the journal a chance to free

701

/* restart the transaction to give the journal a chance to free

702

** some blocks. releases the path, so we have to go back to

702

** some blocks. releases the path, so we have to go back to

703

** research if we succeed on the second try

703

** research if we succeed on the second try

704

*/

704

*/

705

SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;

705

SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;

706

retval = restart_transaction(th, inode, &path);

706

retval = restart_transaction(th, inode, &path);

707

if (retval)

707

if (retval)

708

goto failure;

708

goto failure;

709

repeat =

709

repeat =

710

_allocate_block(th, block, inode,

710

_allocate_block(th, block, inode,

711

&allocated_block_nr, NULL, create);

711

&allocated_block_nr, NULL, create);

712

713

if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {

713

if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {

714

goto research;

714

goto research;

715

}

715

}

716

if (repeat == QUOTA_EXCEEDED)

716

if (repeat == QUOTA_EXCEEDED)

717

retval = -EDQUOT;

717

retval = -EDQUOT;

718

else

718

else

719

retval = -ENOSPC;

719

retval = -ENOSPC;

720

goto failure;

720

goto failure;

721

}

721

}

722

723

if (fs_changed(fs_gen, inode->i_sb)

723

if (fs_changed(fs_gen, inode->i_sb)

724

&& item_moved(&tmp_ih, &path)) {

724

&& item_moved(&tmp_ih, &path)) {

725

goto research;

725

goto research;

726

}

726

}

727

}

727

}

728

729

if (indirect_item_found(retval, ih)) {

729

if (indirect_item_found(retval, ih)) {

730

b_blocknr_t unfm_ptr;

730

b_blocknr_t unfm_ptr;

731

/* 'block'-th block is in the file already (there is

731

/* 'block'-th block is in the file already (there is

732

corresponding cell in some indirect item). But it may be

732

corresponding cell in some indirect item). But it may be

733

zero unformatted node pointer (hole) */

733

zero unformatted node pointer (hole) */

734

unfm_ptr = get_block_num(item, pos_in_item);

734

unfm_ptr = get_block_num(item, pos_in_item);

735

if (unfm_ptr == 0) {

735

if (unfm_ptr == 0) {

736

/* use allocated block to plug the hole */

736

/* use allocated block to plug the hole */

737

reiserfs_prepare_for_journal(inode->i_sb, bh, 1);

737

reiserfs_prepare_for_journal(inode->i_sb, bh, 1);

738

if (fs_changed(fs_gen, inode->i_sb)

738

if (fs_changed(fs_gen, inode->i_sb)

739

&& item_moved(&tmp_ih, &path)) {

739

&& item_moved(&tmp_ih, &path)) {

740

reiserfs_restore_prepared_buffer(inode->i_sb,

740

reiserfs_restore_prepared_buffer(inode->i_sb,

741

bh);

741

bh);

742

goto research;

742

goto research;

743

}

743

}

744

set_buffer_new(bh_result);

744

set_buffer_new(bh_result);

745

if (buffer_dirty(bh_result)

745

if (buffer_dirty(bh_result)

746

&& reiserfs_data_ordered(inode->i_sb))

746

&& reiserfs_data_ordered(inode->i_sb))

747

reiserfs_add_ordered_list(inode, bh_result);

747

reiserfs_add_ordered_list(inode, bh_result);

748

put_block_num(item, pos_in_item, allocated_block_nr);

748

put_block_num(item, pos_in_item, allocated_block_nr);

749

unfm_ptr = allocated_block_nr;

749

unfm_ptr = allocated_block_nr;

750

journal_mark_dirty(th, inode->i_sb, bh);

750

journal_mark_dirty(th, inode->i_sb, bh);

751

reiserfs_update_sd(th, inode);

751

reiserfs_update_sd(th, inode);

752

}

752

}

753

set_block_dev_mapped(bh_result, unfm_ptr, inode);

753

set_block_dev_mapped(bh_result, unfm_ptr, inode);

754

pathrelse(&path);

754

pathrelse(&path);

755

retval = 0;

755

retval = 0;

756

if (!dangle && th)

756

if (!dangle && th)

757

retval = reiserfs_end_persistent_transaction(th);

757

retval = reiserfs_end_persistent_transaction(th);

758

759

reiserfs_write_unlock(inode->i_sb);

759

reiserfs_write_unlock(inode->i_sb);

760

761

/* the item was found, so new blocks were not added to the file

761

/* the item was found, so new blocks were not added to the file

762

** there is no need to make sure the inode is updated with this

762

** there is no need to make sure the inode is updated with this

763

** transaction

763

** transaction

764

*/

764

*/

765

return retval;

765

return retval;

766

}

766

}

767

768

if (!th) {

768

if (!th) {

769

pathrelse(&path);

769

pathrelse(&path);

770

goto start_trans;

770

goto start_trans;

771

}

771

}

772

773

/* desired position is not found or is in the direct item. We have

773

/* desired position is not found or is in the direct item. We have

774

to append file with holes up to 'block'-th block converting

774

to append file with holes up to 'block'-th block converting

775

direct items to indirect one if necessary */

775

direct items to indirect one if necessary */

776

done = 0;

776

done = 0;

777

do {

777

do {

778

if (is_statdata_le_ih(ih)) {

778

if (is_statdata_le_ih(ih)) {

779

__le32 unp = 0;

779

__le32 unp = 0;

780

struct cpu_key tmp_key;

780

struct cpu_key tmp_key;

781

782

/* indirect item has to be inserted */

782

/* indirect item has to be inserted */

783

make_le_item_head(&tmp_ih, &key, version, 1,

783

make_le_item_head(&tmp_ih, &key, version, 1,

784

TYPE_INDIRECT, UNFM_P_SIZE,

784

TYPE_INDIRECT, UNFM_P_SIZE,

785

0 /* free_space */ );

785

0 /* free_space */ );

786

787

if (cpu_key_k_offset(&key) == 1) {

787

if (cpu_key_k_offset(&key) == 1) {

788

/* we are going to add 'block'-th block to the file. Use

788

/* we are going to add 'block'-th block to the file. Use

789

allocated block for that */

789

allocated block for that */

790

unp = cpu_to_le32(allocated_block_nr);

790

unp = cpu_to_le32(allocated_block_nr);

791

set_block_dev_mapped(bh_result,

791

set_block_dev_mapped(bh_result,

792

allocated_block_nr, inode);

792

allocated_block_nr, inode);

793

set_buffer_new(bh_result);

793

set_buffer_new(bh_result);

794

done = 1;

794

done = 1;

795

}

795

}

796

tmp_key = key; // ;)

796

tmp_key = key; // ;)

797

set_cpu_key_k_offset(&tmp_key, 1);

797

set_cpu_key_k_offset(&tmp_key, 1);

798

PATH_LAST_POSITION(&path)++;

798

PATH_LAST_POSITION(&path)++;

799

800

retval =

800

retval =

801

reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,

801

reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,

802

inode, (char *)&unp);

802

inode, (char *)&unp);

803

if (retval) {

803

if (retval) {

804

reiserfs_free_block(th, inode,

804

reiserfs_free_block(th, inode,

805

allocated_block_nr, 1);

805

allocated_block_nr, 1);

806

goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST

806

goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST

807

}

807

}

808

//mark_tail_converted (inode);

808

//mark_tail_converted (inode);

809

} else if (is_direct_le_ih(ih)) {

809

} else if (is_direct_le_ih(ih)) {

810

/* direct item has to be converted */

810

/* direct item has to be converted */

811

loff_t tail_offset;

811

loff_t tail_offset;

812

813

tail_offset =

813

tail_offset =

814

((le_ih_k_offset(ih) -

814

((le_ih_k_offset(ih) -

815

1) & ~(inode->i_sb->s_blocksize - 1)) + 1;

815

1) & ~(inode->i_sb->s_blocksize - 1)) + 1;

816

if (tail_offset == cpu_key_k_offset(&key)) {

816

if (tail_offset == cpu_key_k_offset(&key)) {

817

/* direct item we just found fits into block we have

817

/* direct item we just found fits into block we have

818

to map. Convert it into unformatted node: use

818

to map. Convert it into unformatted node: use

819

bh_result for the conversion */

819

bh_result for the conversion */

820

set_block_dev_mapped(bh_result,

820

set_block_dev_mapped(bh_result,

821

allocated_block_nr, inode);

821

allocated_block_nr, inode);

822

unbh = bh_result;

822

unbh = bh_result;

823

done = 1;

823

done = 1;

824

} else {

824

} else {

825

/* we have to padd file tail stored in direct item(s)

825

/* we have to padd file tail stored in direct item(s)

826

up to block size and convert it to unformatted

826

up to block size and convert it to unformatted

827

node. FIXME: this should also get into page cache */

827

node. FIXME: this should also get into page cache */

828

829

pathrelse(&path);

829

pathrelse(&path);

830

/*

830

/*

831

* ugly, but we can only end the transaction if

831

* ugly, but we can only end the transaction if

832

* we aren't nested

832

* we aren't nested

833

*/

833

*/

834

BUG_ON(!th->t_refcount);

834

BUG_ON(!th->t_refcount);

835

if (th->t_refcount == 1) {

835

if (th->t_refcount == 1) {

836

retval =

836

retval =

837

reiserfs_end_persistent_transaction

837

reiserfs_end_persistent_transaction

838

(th);

838

(th);

839

th = NULL;

839

th = NULL;

840

if (retval)

840

if (retval)

841

goto failure;

841

goto failure;

842

}

842

}

843

844

retval =

844

retval =

845

convert_tail_for_hole(inode, bh_result,

845

convert_tail_for_hole(inode, bh_result,

846

tail_offset);

846

tail_offset);

847

if (retval) {

847

if (retval) {

848

if (retval != -ENOSPC)

848

if (retval != -ENOSPC)

849

reiserfs_warning(inode->i_sb,

849

reiserfs_warning(inode->i_sb,

850

"clm-6004: convert tail failed inode %lu, error %d",

850

"clm-6004: convert tail failed inode %lu, error %d",

851

inode->i_ino,

851

inode->i_ino,

852

retval);

852

retval);

853

if (allocated_block_nr) {

853

if (allocated_block_nr) {

854

/* the bitmap, the super, and the stat data == 3 */

854

/* the bitmap, the super, and the stat data == 3 */

855

if (!th)

855

if (!th)

856

th = reiserfs_persistent_transaction(inode->i_sb, 3);

856

th = reiserfs_persistent_transaction(inode->i_sb, 3);

857

if (th)

857

if (th)

858

reiserfs_free_block(th,

858

reiserfs_free_block(th,

859

inode,

859

inode,

860

allocated_block_nr,

860

allocated_block_nr,

861

1);

861

1);

862

}

862

}

863

goto failure;

863

goto failure;

864

}

864

}

865

goto research;

865

goto research;

866

}

866

}

867

retval =

867

retval =

868

direct2indirect(th, inode, &path, unbh,

868

direct2indirect(th, inode, &path, unbh,

869

tail_offset);

869

tail_offset);

870

if (retval) {

870

if (retval) {

871

reiserfs_unmap_buffer(unbh);

871

reiserfs_unmap_buffer(unbh);

872

reiserfs_free_block(th, inode,

872

reiserfs_free_block(th, inode,

873

allocated_block_nr, 1);

873

allocated_block_nr, 1);

874

goto failure;

874

goto failure;

875

}

875

}

876

/* it is important the set_buffer_uptodate is done after

876

/* it is important the set_buffer_uptodate is done after

877

** the direct2indirect. The buffer might contain valid

877

** the direct2indirect. The buffer might contain valid

878

** data newer than the data on disk (read by readpage, changed,

878

** data newer than the data on disk (read by readpage, changed,

879

** and then sent here by writepage). direct2indirect needs

879

** and then sent here by writepage). direct2indirect needs

880

** to know if unbh was already up to date, so it can decide

880

** to know if unbh was already up to date, so it can decide

881

** if the data in unbh needs to be replaced with data from

881

** if the data in unbh needs to be replaced with data from

882

** the disk

882

** the disk

883

*/

883

*/

884

set_buffer_uptodate(unbh);

884

set_buffer_uptodate(unbh);

885

886

/* unbh->b_page == NULL in case of DIRECT_IO request, this means

886

/* unbh->b_page == NULL in case of DIRECT_IO request, this means

887

buffer will disappear shortly, so it should not be added to

887

buffer will disappear shortly, so it should not be added to

888

*/

888

*/

889

if (unbh->b_page) {

889

if (unbh->b_page) {

890

/* we've converted the tail, so we must

890

/* we've converted the tail, so we must

891

** flush unbh before the transaction commits

891

** flush unbh before the transaction commits

892

*/

892

*/

893

reiserfs_add_tail_list(inode, unbh);

893

reiserfs_add_tail_list(inode, unbh);

894

895

/* mark it dirty now to prevent commit_write from adding

895

/* mark it dirty now to prevent commit_write from adding

896

** this buffer to the inode's dirty buffer list

896

** this buffer to the inode's dirty buffer list

897

*/

897

*/

898

/*

898

/*

899

* AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().

899

* AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().

900

* It's still atomic, but it sets the page dirty too,

900

* It's still atomic, but it sets the page dirty too,

901

* which makes it eligible for writeback at any time by the

901

* which makes it eligible for writeback at any time by the

902

* VM (which was also the case with __mark_buffer_dirty())

902

* VM (which was also the case with __mark_buffer_dirty())

903

*/

903

*/

904

mark_buffer_dirty(unbh);

904

mark_buffer_dirty(unbh);

905

}

905

}

906

} else {

906

} else {

907

/* append indirect item with holes if needed, when appending

907

/* append indirect item with holes if needed, when appending

908

pointer to 'block'-th block use block, which is already

908

pointer to 'block'-th block use block, which is already

909

allocated */

909

allocated */

910

struct cpu_key tmp_key;

910

struct cpu_key tmp_key;

911

unp_t unf_single = 0; // We use this in case we need to allocate only

911

unp_t unf_single = 0; // We use this in case we need to allocate only

912

// one block which is a fastpath

912

// one block which is a fastpath

913

unp_t *un;

913

unp_t *un;

914

__u64 max_to_insert =

914

__u64 max_to_insert =

915

MAX_ITEM_LEN(inode->i_sb->s_blocksize) /

915

MAX_ITEM_LEN(inode->i_sb->s_blocksize) /

916

UNFM_P_SIZE;

916

UNFM_P_SIZE;

917

__u64 blocks_needed;

917

__u64 blocks_needed;

918

919

RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,

919

RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,

920

"vs-804: invalid position for append");

920

"vs-804: invalid position for append");

921

/* indirect item has to be appended, set up key of that position */

921

/* indirect item has to be appended, set up key of that position */

922

make_cpu_key(&tmp_key, inode,

922

make_cpu_key(&tmp_key, inode,

923

le_key_k_offset(version,

923

le_key_k_offset(version,

924

&(ih->ih_key)) +

924

&(ih->ih_key)) +

925

op_bytes_number(ih,

925

op_bytes_number(ih,

926

inode->i_sb->s_blocksize),

926

inode->i_sb->s_blocksize),

927

//pos_in_item * inode->i_sb->s_blocksize,

927

//pos_in_item * inode->i_sb->s_blocksize,

928

TYPE_INDIRECT, 3); // key type is unimportant

928

TYPE_INDIRECT, 3); // key type is unimportant

929

930

blocks_needed =

930

blocks_needed =

931

1 +

931

1 +

932

((cpu_key_k_offset(&key) -

932

((cpu_key_k_offset(&key) -

933

cpu_key_k_offset(&tmp_key)) >> inode->i_sb->

933

cpu_key_k_offset(&tmp_key)) >> inode->i_sb->

934

s_blocksize_bits);

934

s_blocksize_bits);

935

RFALSE(blocks_needed < 0, "green-805: invalid offset");

935

RFALSE(blocks_needed < 0, "green-805: invalid offset");

936

937

if (blocks_needed == 1) {

937

if (blocks_needed == 1) {

938

un = &unf_single;

938

un = &unf_single;

939

} else {

939

} else {

940

un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC); // We need to avoid scheduling.

940

un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC); // We need to avoid scheduling.

941

if (!un) {

941

if (!un) {

942

un = &unf_single;

942

un = &unf_single;

943

blocks_needed = 1;

943

blocks_needed = 1;

944

max_to_insert = 0;

944

max_to_insert = 0;

945

} else

945

} else

946

memset(un, 0,

946

memset(un, 0,

947

UNFM_P_SIZE * min(blocks_needed,

947

UNFM_P_SIZE * min(blocks_needed,

948

max_to_insert));

948

max_to_insert));

949

}

949

}

950

if (blocks_needed <= max_to_insert) {

950

if (blocks_needed <= max_to_insert) {

951

/* we are going to add target block to the file. Use allocated

951

/* we are going to add target block to the file. Use allocated

952

block for that */

952

block for that */

953

un[blocks_needed - 1] =

953

un[blocks_needed - 1] =

954

cpu_to_le32(allocated_block_nr);

954

cpu_to_le32(allocated_block_nr);

955

set_block_dev_mapped(bh_result,

955

set_block_dev_mapped(bh_result,

956

allocated_block_nr, inode);

956

allocated_block_nr, inode);

957

set_buffer_new(bh_result);

957

set_buffer_new(bh_result);

958

done = 1;

958

done = 1;

959

} else {

959

} else {

960

/* paste hole to the indirect item */

960

/* paste hole to the indirect item */

961

/* If kmalloc failed, max_to_insert becomes zero and it means we

961

/* If kmalloc failed, max_to_insert becomes zero and it means we

962

only have space for one block */

962

only have space for one block */

963

blocks_needed =

963

blocks_needed =

964

max_to_insert ? max_to_insert : 1;

964

max_to_insert ? max_to_insert : 1;

965

}

965

}

966

retval =

966

retval =

967

reiserfs_paste_into_item(th, &path, &tmp_key, inode,

967

reiserfs_paste_into_item(th, &path, &tmp_key, inode,

968

(char *)un,

968

(char *)un,

969

UNFM_P_SIZE *

969

UNFM_P_SIZE *

970

blocks_needed);

970

blocks_needed);

971

972

if (blocks_needed != 1)

972

if (blocks_needed != 1)

973

kfree(un);

973

kfree(un);

974

975

if (retval) {

975

if (retval) {

976

reiserfs_free_block(th, inode,

976

reiserfs_free_block(th, inode,

977

allocated_block_nr, 1);

977

allocated_block_nr, 1);

978

goto failure;

978

goto failure;

979

}

979

}

980

if (!done) {

980

if (!done) {

981

/* We need to mark new file size in case this function will be

981

/* We need to mark new file size in case this function will be

982

interrupted/aborted later on. And we may do this only for

982

interrupted/aborted later on. And we may do this only for

983

holes. */

983

holes. */

984

inode->i_size +=

984

inode->i_size +=

985

inode->i_sb->s_blocksize * blocks_needed;

985

inode->i_sb->s_blocksize * blocks_needed;

986

}

986

}

987

}

987

}

988

989

if (done == 1)

989

if (done == 1)

990

break;

990

break;

991

992

/* this loop could log more blocks than we had originally asked

992

/* this loop could log more blocks than we had originally asked

993

** for. So, we have to allow the transaction to end if it is

993

** for. So, we have to allow the transaction to end if it is

994

** too big or too full. Update the inode so things are

994

** too big or too full. Update the inode so things are

995

** consistent if we crash before the function returns

995

** consistent if we crash before the function returns

996

**

996

**

997

** release the path so that anybody waiting on the path before

997

** release the path so that anybody waiting on the path before

998

** ending their transaction will be able to continue.

998

** ending their transaction will be able to continue.

999

*/

999

*/

1000

if (journal_transaction_should_end(th, th->t_blocks_allocated)) {

1000

if (journal_transaction_should_end(th, th->t_blocks_allocated)) {

1001

retval = restart_transaction(th, inode, &path);

1001

retval = restart_transaction(th, inode, &path);

1002

if (retval)

1002

if (retval)

1003

goto failure;

1003

goto failure;

1004

}

1004

}

1005

/* inserting indirect pointers for a hole can take a

1005

/* inserting indirect pointers for a hole can take a

1006

** long time. reschedule if needed

1006

** long time. reschedule if needed

1007

*/

1007

*/

1008

cond_resched();

1008

cond_resched();

1009

1010

retval = search_for_position_by_key(inode->i_sb, &key, &path);

1010

retval = search_for_position_by_key(inode->i_sb, &key, &path);

1011

if (retval == IO_ERROR) {

1011

if (retval == IO_ERROR) {

1012

retval = -EIO;

1012

retval = -EIO;

1013

goto failure;

1013

goto failure;

1014

}

1014

}

1015

if (retval == POSITION_FOUND) {

1015

if (retval == POSITION_FOUND) {

1016

reiserfs_warning(inode->i_sb,

1016

reiserfs_warning(inode->i_sb,

1017

"vs-825: reiserfs_get_block: "

1017

"vs-825: reiserfs_get_block: "

1018

"%K should not be found", &key);

1018

"%K should not be found", &key);

1019

retval = -EEXIST;

1019

retval = -EEXIST;

1020

if (allocated_block_nr)

1020

if (allocated_block_nr)

1021

reiserfs_free_block(th, inode,

1021

reiserfs_free_block(th, inode,

1022

allocated_block_nr, 1);

1022

allocated_block_nr, 1);

1023

pathrelse(&path);

1023

pathrelse(&path);

1024

goto failure;

1024

goto failure;

1025

}

1025

}

1026

bh = get_last_bh(&path);

1026

bh = get_last_bh(&path);

1027

ih = get_ih(&path);

1027

ih = get_ih(&path);

1028

item = get_item(&path);

1028

item = get_item(&path);

1029

pos_in_item = path.pos_in_item;

1029

pos_in_item = path.pos_in_item;

1030

} while (1);

1030

} while (1);

1031

1032

retval = 0;

1032

retval = 0;

1033

1034

failure:

1034

failure:

1035

if (th && (!dangle || (retval && !th->t_trans_id))) {

1035

if (th && (!dangle || (retval && !th->t_trans_id))) {

1036

int err;

1036

int err;

1037

if (th->t_trans_id)

1037

if (th->t_trans_id)

1038

reiserfs_update_sd(th, inode);

1038

reiserfs_update_sd(th, inode);

1039

err = reiserfs_end_persistent_transaction(th);

1039

err = reiserfs_end_persistent_transaction(th);

1040

if (err)

1040

if (err)

1041

retval = err;

1041

retval = err;

1042

}

1042

}

1043

1044

reiserfs_write_unlock(inode->i_sb);

1044

reiserfs_write_unlock(inode->i_sb);

1045

reiserfs_check_path(&path);

1045

reiserfs_check_path(&path);

1046

return retval;

1046

return retval;

1047

}

1047

}

1048

1049

static int

1049

static int

1050

reiserfs_readpages(struct file *file, struct address_space *mapping,

1050

reiserfs_readpages(struct file *file, struct address_space *mapping,

1051

struct list_head *pages, unsigned nr_pages)

1051

struct list_head *pages, unsigned nr_pages)

1052

{

1052

{

1053

return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);

1053

return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);

1054

}

1054

}

1055

1056

/* Compute real number of used bytes by file

1056

/* Compute real number of used bytes by file

1057

* Following three functions can go away when we'll have enough space in stat item

1057

* Following three functions can go away when we'll have enough space in stat item

1058

*/

1058

*/

1059

static int real_space_diff(struct inode *inode, int sd_size)

1059

static int real_space_diff(struct inode *inode, int sd_size)

1060

{

1060

{

1061

int bytes;

1061

int bytes;

1062

loff_t blocksize = inode->i_sb->s_blocksize;

1062

loff_t blocksize = inode->i_sb->s_blocksize;

1063

1064

if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))

1064

if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))

1065

return sd_size;

1065

return sd_size;

1066

1067

/* End of file is also in full block with indirect reference, so round

1067

/* End of file is also in full block with indirect reference, so round

1068

** up to the next block.

1068

** up to the next block.

1069

**

1069

**

1070

** there is just no way to know if the tail is actually packed

1070

** there is just no way to know if the tail is actually packed

1071

** on the file, so we have to assume it isn't. When we pack the

1071

** on the file, so we have to assume it isn't. When we pack the

1072

** tail, we add 4 bytes to pretend there really is an unformatted

1072

** tail, we add 4 bytes to pretend there really is an unformatted

1073

** node pointer

1073

** node pointer

1074

*/

1074

*/

1075

bytes =

1075

bytes =

1076

((inode->i_size +

1076

((inode->i_size +

1077

(blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +

1077

(blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +

1078

sd_size;

1078

sd_size;

1079

return bytes;

1079

return bytes;

1080

}

1080

}

1081

1082

static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,

1082

static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,

1083

int sd_size)

1083

int sd_size)

1084

{

1084

{

1085

if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {

1085

if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {

1086

return inode->i_size +

1086

return inode->i_size +

1087

(loff_t) (real_space_diff(inode, sd_size));

1087

(loff_t) (real_space_diff(inode, sd_size));

1088

}

1088

}

1089

return ((loff_t) real_space_diff(inode, sd_size)) +

1089

return ((loff_t) real_space_diff(inode, sd_size)) +

1090

(((loff_t) blocks) << 9);

1090

(((loff_t) blocks) << 9);

1091

}

1091

}

1092

1093

/* Compute number of blocks used by file in ReiserFS counting */

1093

/* Compute number of blocks used by file in ReiserFS counting */

1094

static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)

1094

static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)

1095

{

1095

{

1096

loff_t bytes = inode_get_bytes(inode);

1096

loff_t bytes = inode_get_bytes(inode);

1097

loff_t real_space = real_space_diff(inode, sd_size);

1097

loff_t real_space = real_space_diff(inode, sd_size);

1098

1099

/* keeps fsck and non-quota versions of reiserfs happy */

1099

/* keeps fsck and non-quota versions of reiserfs happy */

1100

if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {

1100

if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {

1101

bytes += (loff_t) 511;

1101

bytes += (loff_t) 511;

1102

}

1102

}

1103

1104

/* files from before the quota patch might i_blocks such that

1104

/* files from before the quota patch might i_blocks such that

1105

** bytes < real_space. Deal with that here to prevent it from

1105

** bytes < real_space. Deal with that here to prevent it from

1106

** going negative.

1106

** going negative.

1107

*/

1107

*/

1108

if (bytes < real_space)

1108

if (bytes < real_space)

1109

return 0;

1109

return 0;

1110

return (bytes - real_space) >> 9;

1110

return (bytes - real_space) >> 9;

1111

}

1111

}

1112

1113

//

1113

//

1114

// BAD: new directories have stat data of new type and all other items

1114

// BAD: new directories have stat data of new type and all other items

1115

// of old type. Version stored in the inode says about body items, so

1115

// of old type. Version stored in the inode says about body items, so

1116

// in update_stat_data we can not rely on inode, but have to check

1116

// in update_stat_data we can not rely on inode, but have to check

1117

// item version directly

1117

// item version directly

1118

//

1118

//

1119

1120

// called by read_locked_inode

1120

// called by read_locked_inode

1121

static void init_inode(struct inode *inode, struct path *path)

1121

static void init_inode(struct inode *inode, struct path *path)

1122

{

1122

{

1123

struct buffer_head *bh;

1123

struct buffer_head *bh;

1124

struct item_head *ih;

1124

struct item_head *ih;

1125

__u32 rdev;

1125

__u32 rdev;

1126

//int version = ITEM_VERSION_1;

1126

//int version = ITEM_VERSION_1;

1127

1128

bh = PATH_PLAST_BUFFER(path);

1128

bh = PATH_PLAST_BUFFER(path);

1129

ih = PATH_PITEM_HEAD(path);

1129

ih = PATH_PITEM_HEAD(path);

1130

1131

copy_key(INODE_PKEY(inode), &(ih->ih_key));

1131

copy_key(INODE_PKEY(inode), &(ih->ih_key));

1132

inode->i_blksize = reiserfs_default_io_size;

1132

inode->i_blksize = reiserfs_default_io_size;

1133

1134

INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));

1134

INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));

1135

REISERFS_I(inode)->i_flags = 0;

1135

REISERFS_I(inode)->i_flags = 0;

1136

REISERFS_I(inode)->i_prealloc_block = 0;

1136

REISERFS_I(inode)->i_prealloc_block = 0;

1137

REISERFS_I(inode)->i_prealloc_count = 0;

1137

REISERFS_I(inode)->i_prealloc_count = 0;

1138

REISERFS_I(inode)->i_trans_id = 0;

1138

REISERFS_I(inode)->i_trans_id = 0;

1139

REISERFS_I(inode)->i_jl = NULL;

1139

REISERFS_I(inode)->i_jl = NULL;

1140

REISERFS_I(inode)->i_acl_access = NULL;

1140

REISERFS_I(inode)->i_acl_access = NULL;

1141

REISERFS_I(inode)->i_acl_default = NULL;

1141

REISERFS_I(inode)->i_acl_default = NULL;

1142

init_rwsem(&REISERFS_I(inode)->xattr_sem);

1142

init_rwsem(&REISERFS_I(inode)->xattr_sem);

1143

1144

if (stat_data_v1(ih)) {

1144

if (stat_data_v1(ih)) {

1145

struct stat_data_v1 *sd =

1145

struct stat_data_v1 *sd =

1146

(struct stat_data_v1 *)B_I_PITEM(bh, ih);

1146

(struct stat_data_v1 *)B_I_PITEM(bh, ih);

1147

unsigned long blocks;

1147

unsigned long blocks;

1148

1149

set_inode_item_key_version(inode, KEY_FORMAT_3_5);

1149

set_inode_item_key_version(inode, KEY_FORMAT_3_5);

1150

set_inode_sd_version(inode, STAT_DATA_V1);

1150

set_inode_sd_version(inode, STAT_DATA_V1);

1151

inode->i_mode = sd_v1_mode(sd);

1151

inode->i_mode = sd_v1_mode(sd);

1152

inode->i_nlink = sd_v1_nlink(sd);

1152

inode->i_nlink = sd_v1_nlink(sd);

1153

inode->i_uid = sd_v1_uid(sd);

1153

inode->i_uid = sd_v1_uid(sd);

1154

inode->i_gid = sd_v1_gid(sd);

1154

inode->i_gid = sd_v1_gid(sd);

1155

inode->i_size = sd_v1_size(sd);

1155

inode->i_size = sd_v1_size(sd);

1156

inode->i_atime.tv_sec = sd_v1_atime(sd);

1156

inode->i_atime.tv_sec = sd_v1_atime(sd);

1157

inode->i_mtime.tv_sec = sd_v1_mtime(sd);

1157

inode->i_mtime.tv_sec = sd_v1_mtime(sd);

1158

inode->i_ctime.tv_sec = sd_v1_ctime(sd);

1158

inode->i_ctime.tv_sec = sd_v1_ctime(sd);

1159

inode->i_atime.tv_nsec = 0;

1159

inode->i_atime.tv_nsec = 0;

1160

inode->i_ctime.tv_nsec = 0;

1160

inode->i_ctime.tv_nsec = 0;

1161

inode->i_mtime.tv_nsec = 0;

1161

inode->i_mtime.tv_nsec = 0;

1162

1163

inode->i_blocks = sd_v1_blocks(sd);

1163

inode->i_blocks = sd_v1_blocks(sd);

1164

inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1164

inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1165

blocks = (inode->i_size + 511) >> 9;

1165

blocks = (inode->i_size + 511) >> 9;

1166

blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);

1166

blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);

1167

if (inode->i_blocks > blocks) {

1167

if (inode->i_blocks > blocks) {

1168

// there was a bug in <=3.5.23 when i_blocks could take negative

1168

// there was a bug in <=3.5.23 when i_blocks could take negative

1169

// values. Starting from 3.5.17 this value could even be stored in

1169

// values. Starting from 3.5.17 this value could even be stored in

1170

// stat data. For such files we set i_blocks based on file

1170

// stat data. For such files we set i_blocks based on file

1171

// size. Just 2 notes: this can be wrong for sparce files. On-disk value will be

1171

// size. Just 2 notes: this can be wrong for sparce files. On-disk value will be

1172

// only updated if file's inode will ever change

1172

// only updated if file's inode will ever change

1173

inode->i_blocks = blocks;

1173

inode->i_blocks = blocks;

1174

}

1174

}

1175

1176

rdev = sd_v1_rdev(sd);

1176

rdev = sd_v1_rdev(sd);

1177

REISERFS_I(inode)->i_first_direct_byte =

1177

REISERFS_I(inode)->i_first_direct_byte =

1178

sd_v1_first_direct_byte(sd);

1178

sd_v1_first_direct_byte(sd);

1179

/* an early bug in the quota code can give us an odd number for the

1179

/* an early bug in the quota code can give us an odd number for the

1180

** block count. This is incorrect, fix it here.

1180

** block count. This is incorrect, fix it here.

1181

*/

1181

*/

1182

if (inode->i_blocks & 1) {

1182

if (inode->i_blocks & 1) {

1183

inode->i_blocks++;

1183

inode->i_blocks++;

1184

}

1184

}

1185

inode_set_bytes(inode,

1185

inode_set_bytes(inode,

1186

to_real_used_space(inode, inode->i_blocks,

1186

to_real_used_space(inode, inode->i_blocks,

1187

SD_V1_SIZE));

1187

SD_V1_SIZE));

1188

/* nopack is initially zero for v1 objects. For v2 objects,

1188

/* nopack is initially zero for v1 objects. For v2 objects,

1189

nopack is initialised from sd_attrs */

1189

nopack is initialised from sd_attrs */

1190

REISERFS_I(inode)->i_flags &= ~i_nopack_mask;

1190

REISERFS_I(inode)->i_flags &= ~i_nopack_mask;

1191

} else {

1191

} else {

1192

// new stat data found, but object may have old items

1192

// new stat data found, but object may have old items

1193

// (directories and symlinks)

1193

// (directories and symlinks)

1194

struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);

1194

struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);

1195

1196

inode->i_mode = sd_v2_mode(sd);

1196

inode->i_mode = sd_v2_mode(sd);

1197

inode->i_nlink = sd_v2_nlink(sd);

1197

inode->i_nlink = sd_v2_nlink(sd);

1198

inode->i_uid = sd_v2_uid(sd);

1198

inode->i_uid = sd_v2_uid(sd);

1199

inode->i_size = sd_v2_size(sd);

1199

inode->i_size = sd_v2_size(sd);

1200

inode->i_gid = sd_v2_gid(sd);

1200

inode->i_gid = sd_v2_gid(sd);

1201

inode->i_mtime.tv_sec = sd_v2_mtime(sd);

1201

inode->i_mtime.tv_sec = sd_v2_mtime(sd);

1202

inode->i_atime.tv_sec = sd_v2_atime(sd);

1202

inode->i_atime.tv_sec = sd_v2_atime(sd);

1203

inode->i_ctime.tv_sec = sd_v2_ctime(sd);

1203

inode->i_ctime.tv_sec = sd_v2_ctime(sd);

1204

inode->i_ctime.tv_nsec = 0;

1204

inode->i_ctime.tv_nsec = 0;

1205

inode->i_mtime.tv_nsec = 0;

1205

inode->i_mtime.tv_nsec = 0;

1206

inode->i_atime.tv_nsec = 0;

1206

inode->i_atime.tv_nsec = 0;

1207

inode->i_blocks = sd_v2_blocks(sd);

1207

inode->i_blocks = sd_v2_blocks(sd);

1208

rdev = sd_v2_rdev(sd);

1208

rdev = sd_v2_rdev(sd);

1209

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

1209

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

1210

inode->i_generation =

1210

inode->i_generation =

1211

le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1211

le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1212

else

1212

else

1213

inode->i_generation = sd_v2_generation(sd);

1213

inode->i_generation = sd_v2_generation(sd);

1214

1215

if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))

1215

if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))

1216

set_inode_item_key_version(inode, KEY_FORMAT_3_5);

1216

set_inode_item_key_version(inode, KEY_FORMAT_3_5);

1217

else

1217

else

1218

set_inode_item_key_version(inode, KEY_FORMAT_3_6);

1218

set_inode_item_key_version(inode, KEY_FORMAT_3_6);

1219

REISERFS_I(inode)->i_first_direct_byte = 0;

1219

REISERFS_I(inode)->i_first_direct_byte = 0;

1220

set_inode_sd_version(inode, STAT_DATA_V2);

1220

set_inode_sd_version(inode, STAT_DATA_V2);

1221

inode_set_bytes(inode,

1221

inode_set_bytes(inode,

1222

to_real_used_space(inode, inode->i_blocks,

1222

to_real_used_space(inode, inode->i_blocks,

1223

SD_V2_SIZE));

1223

SD_V2_SIZE));

1224

/* read persistent inode attributes from sd and initalise

1224

/* read persistent inode attributes from sd and initalise

1225

generic inode flags from them */

1225

generic inode flags from them */

1226

REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);

1226

REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);

1227

sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);

1227

sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);

1228

}

1228

}

1229

1230

pathrelse(path);

1230

pathrelse(path);

1231

if (S_ISREG(inode->i_mode)) {

1231

if (S_ISREG(inode->i_mode)) {

1232

inode->i_op = &reiserfs_file_inode_operations;

1232

inode->i_op = &reiserfs_file_inode_operations;

1233

inode->i_fop = &reiserfs_file_operations;

1233

inode->i_fop = &reiserfs_file_operations;

1234

inode->i_mapping->a_ops = &reiserfs_address_space_operations;

1234

inode->i_mapping->a_ops = &reiserfs_address_space_operations;

1235

} else if (S_ISDIR(inode->i_mode)) {

1235

} else if (S_ISDIR(inode->i_mode)) {

1236

inode->i_op = &reiserfs_dir_inode_operations;

1236

inode->i_op = &reiserfs_dir_inode_operations;

1237

inode->i_fop = &reiserfs_dir_operations;

1237

inode->i_fop = &reiserfs_dir_operations;

1238

} else if (S_ISLNK(inode->i_mode)) {

1238

} else if (S_ISLNK(inode->i_mode)) {

1239

inode->i_op = &reiserfs_symlink_inode_operations;

1239

inode->i_op = &reiserfs_symlink_inode_operations;

1240

inode->i_mapping->a_ops = &reiserfs_address_space_operations;

1240

inode->i_mapping->a_ops = &reiserfs_address_space_operations;

1241

} else {

1241

} else {

1242

inode->i_blocks = 0;

1242

inode->i_blocks = 0;

1243

inode->i_op = &reiserfs_special_inode_operations;

1243

inode->i_op = &reiserfs_special_inode_operations;

1244

init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));

1244

init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));

1245

}

1245

}

1246

}

1246

}

1247

1248

// update new stat data with inode fields

1248

// update new stat data with inode fields

1249

static void inode2sd(void *sd, struct inode *inode, loff_t size)

1249

static void inode2sd(void *sd, struct inode *inode, loff_t size)

1250

{

1250

{

1251

struct stat_data *sd_v2 = (struct stat_data *)sd;

1251

struct stat_data *sd_v2 = (struct stat_data *)sd;

1252

__u16 flags;

1252

__u16 flags;

1253

1254

set_sd_v2_mode(sd_v2, inode->i_mode);

1254

set_sd_v2_mode(sd_v2, inode->i_mode);

1255

set_sd_v2_nlink(sd_v2, inode->i_nlink);

1255

set_sd_v2_nlink(sd_v2, inode->i_nlink);

1256

set_sd_v2_uid(sd_v2, inode->i_uid);

1256

set_sd_v2_uid(sd_v2, inode->i_uid);

1257

set_sd_v2_size(sd_v2, size);

1257

set_sd_v2_size(sd_v2, size);

1258

set_sd_v2_gid(sd_v2, inode->i_gid);

1258

set_sd_v2_gid(sd_v2, inode->i_gid);

1259

set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);

1259

set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);

1260

set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);

1260

set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);

1261

set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);

1261

set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);

1262

set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));

1262

set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));

1263

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

1263

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

1264

set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));

1264

set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));

1265

else

1265

else

1266

set_sd_v2_generation(sd_v2, inode->i_generation);

1266

set_sd_v2_generation(sd_v2, inode->i_generation);

1267

flags = REISERFS_I(inode)->i_attrs;

1267

flags = REISERFS_I(inode)->i_attrs;

1268

i_attrs_to_sd_attrs(inode, &flags);

1268

i_attrs_to_sd_attrs(inode, &flags);

1269

set_sd_v2_attrs(sd_v2, flags);

1269

set_sd_v2_attrs(sd_v2, flags);

1270

}

1270

}

1271

1272

// used to copy inode's fields to old stat data

1272

// used to copy inode's fields to old stat data

1273

static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)

1273

static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)

1274

{

1274

{

1275

struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;

1275

struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;

1276

1277

set_sd_v1_mode(sd_v1, inode->i_mode);

1277

set_sd_v1_mode(sd_v1, inode->i_mode);

1278

set_sd_v1_uid(sd_v1, inode->i_uid);

1278

set_sd_v1_uid(sd_v1, inode->i_uid);

1279

set_sd_v1_gid(sd_v1, inode->i_gid);

1279

set_sd_v1_gid(sd_v1, inode->i_gid);

1280

set_sd_v1_nlink(sd_v1, inode->i_nlink);

1280

set_sd_v1_nlink(sd_v1, inode->i_nlink);

1281

set_sd_v1_size(sd_v1, size);

1281

set_sd_v1_size(sd_v1, size);

1282

set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);

1282

set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);

1283

set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);

1283

set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);

1284

set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);

1284

set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);

1285

1286

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

1286

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

1287

set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));

1287

set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));

1288

else

1288

else

1289

set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));

1289

set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));

1290

1291

// Sigh. i_first_direct_byte is back

1291

// Sigh. i_first_direct_byte is back

1292

set_sd_v1_first_direct_byte(sd_v1,

1292

set_sd_v1_first_direct_byte(sd_v1,

1293

REISERFS_I(inode)->i_first_direct_byte);

1293

REISERFS_I(inode)->i_first_direct_byte);

1294

}

1294

}

1295

1296

/* NOTE, you must prepare the buffer head before sending it here,

1296

/* NOTE, you must prepare the buffer head before sending it here,

1297

** and then log it after the call

1297

** and then log it after the call

1298

*/

1298

*/

1299

static void update_stat_data(struct path *path, struct inode *inode,

1299

static void update_stat_data(struct path *path, struct inode *inode,

1300

loff_t size)

1300

loff_t size)

1301

{

1301

{

1302

struct buffer_head *bh;

1302

struct buffer_head *bh;

1303

struct item_head *ih;

1303

struct item_head *ih;

1304

1305

bh = PATH_PLAST_BUFFER(path);

1305

bh = PATH_PLAST_BUFFER(path);

1306

ih = PATH_PITEM_HEAD(path);

1306

ih = PATH_PITEM_HEAD(path);

1307

1308

if (!is_statdata_le_ih(ih))

1308

if (!is_statdata_le_ih(ih))

1309

reiserfs_panic(inode->i_sb,

1309

reiserfs_panic(inode->i_sb,

1310

"vs-13065: update_stat_data: key %k, found item %h",

1310

"vs-13065: update_stat_data: key %k, found item %h",

1311

INODE_PKEY(inode), ih);

1311

INODE_PKEY(inode), ih);

1312

1313

if (stat_data_v1(ih)) {

1313

if (stat_data_v1(ih)) {

1314

// path points to old stat data

1314

// path points to old stat data

1315

inode2sd_v1(B_I_PITEM(bh, ih), inode, size);

1315

inode2sd_v1(B_I_PITEM(bh, ih), inode, size);

1316

} else {

1316

} else {

1317

inode2sd(B_I_PITEM(bh, ih), inode, size);

1317

inode2sd(B_I_PITEM(bh, ih), inode, size);

1318

}

1318

}

1319

1320

return;

1320

return;

1321

}

1321

}

1322

1323

void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,

1323

void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,

1324

struct inode *inode, loff_t size)

1324

struct inode *inode, loff_t size)

1325

{

1325

{

1326

struct cpu_key key;

1326

struct cpu_key key;

1327

INITIALIZE_PATH(path);

1327

INITIALIZE_PATH(path);

1328

struct buffer_head *bh;

1328

struct buffer_head *bh;

1329

int fs_gen;

1329

int fs_gen;

1330

struct item_head *ih, tmp_ih;

1330

struct item_head *ih, tmp_ih;

1331

int retval;

1331

int retval;

1332

1333

BUG_ON(!th->t_trans_id);

1333

BUG_ON(!th->t_trans_id);

1334

1335

make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3); //key type is unimportant

1335

make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3); //key type is unimportant

1336

1337

for (;;) {

1337

for (;;) {

1338

int pos;

1338

int pos;

1339

/* look for the object's stat data */

1339

/* look for the object's stat data */

1340

retval = search_item(inode->i_sb, &key, &path);

1340

retval = search_item(inode->i_sb, &key, &path);

1341

if (retval == IO_ERROR) {

1341

if (retval == IO_ERROR) {

1342

reiserfs_warning(inode->i_sb,

1342

reiserfs_warning(inode->i_sb,

1343

"vs-13050: reiserfs_update_sd: "

1343

"vs-13050: reiserfs_update_sd: "

1344

"i/o failure occurred trying to update %K stat data",

1344

"i/o failure occurred trying to update %K stat data",

1345

&key);

1345

&key);

1346

return;

1346

return;

1347

}

1347

}

1348

if (retval == ITEM_NOT_FOUND) {

1348

if (retval == ITEM_NOT_FOUND) {

1349

pos = PATH_LAST_POSITION(&path);

1349

pos = PATH_LAST_POSITION(&path);

1350

pathrelse(&path);

1350

pathrelse(&path);

1351

if (inode->i_nlink == 0) {

1351

if (inode->i_nlink == 0) {

1352

/*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */

1352

/*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */

1353

return;

1353

return;

1354

}

1354

}

1355

reiserfs_warning(inode->i_sb,

1355

reiserfs_warning(inode->i_sb,

1356

"vs-13060: reiserfs_update_sd: "

1356

"vs-13060: reiserfs_update_sd: "

1357

"stat data of object %k (nlink == %d) not found (pos %d)",

1357

"stat data of object %k (nlink == %d) not found (pos %d)",

1358

INODE_PKEY(inode), inode->i_nlink,

1358

INODE_PKEY(inode), inode->i_nlink,

1359

pos);

1359

pos);

1360

reiserfs_check_path(&path);

1360

reiserfs_check_path(&path);

1361

return;

1361

return;

1362

}

1362

}

1363

1364

/* sigh, prepare_for_journal might schedule. When it schedules the

1364

/* sigh, prepare_for_journal might schedule. When it schedules the

1365

** FS might change. We have to detect that, and loop back to the

1365

** FS might change. We have to detect that, and loop back to the

1366

** search if the stat data item has moved

1366

** search if the stat data item has moved

1367

*/

1367

*/

1368

bh = get_last_bh(&path);

1368

bh = get_last_bh(&path);

1369

ih = get_ih(&path);

1369

ih = get_ih(&path);

1370

copy_item_head(&tmp_ih, ih);

1370

copy_item_head(&tmp_ih, ih);

1371

fs_gen = get_generation(inode->i_sb);

1371

fs_gen = get_generation(inode->i_sb);

1372

reiserfs_prepare_for_journal(inode->i_sb, bh, 1);

1372

reiserfs_prepare_for_journal(inode->i_sb, bh, 1);

1373

if (fs_changed(fs_gen, inode->i_sb)

1373

if (fs_changed(fs_gen, inode->i_sb)

1374

&& item_moved(&tmp_ih, &path)) {

1374

&& item_moved(&tmp_ih, &path)) {

1375

reiserfs_restore_prepared_buffer(inode->i_sb, bh);

1375

reiserfs_restore_prepared_buffer(inode->i_sb, bh);

1376

continue; /* Stat_data item has been moved after scheduling. */

1376

continue; /* Stat_data item has been moved after scheduling. */

1377

}

1377

}

1378

break;

1378

break;

1379

}

1379

}

1380

update_stat_data(&path, inode, size);

1380

update_stat_data(&path, inode, size);

1381

journal_mark_dirty(th, th->t_super, bh);

1381

journal_mark_dirty(th, th->t_super, bh);

1382

pathrelse(&path);

1382

pathrelse(&path);

1383

return;

1383

return;

1384

}

1384

}

1385

1386

/* reiserfs_read_locked_inode is called to read the inode off disk, and it

1386

/* reiserfs_read_locked_inode is called to read the inode off disk, and it

1387

** does a make_bad_inode when things go wrong. But, we need to make sure

1387

** does a make_bad_inode when things go wrong. But, we need to make sure

1388

** and clear the key in the private portion of the inode, otherwise a

1388

** and clear the key in the private portion of the inode, otherwise a

1389

** corresponding iput might try to delete whatever object the inode last

1389

** corresponding iput might try to delete whatever object the inode last

1390

** represented.

1390

** represented.

1391

*/

1391

*/

1392

static void reiserfs_make_bad_inode(struct inode *inode)

1392

static void reiserfs_make_bad_inode(struct inode *inode)

1393

{

1393

{

1394

memset(INODE_PKEY(inode), 0, KEY_SIZE);

1394

memset(INODE_PKEY(inode), 0, KEY_SIZE);

1395

make_bad_inode(inode);

1395

make_bad_inode(inode);

1396

}

1396

}

1397

1398

//

1398

//

1399

// initially this function was derived from minix or ext2's analog and

1399

// initially this function was derived from minix or ext2's analog and

1400

// evolved as the prototype did

1400

// evolved as the prototype did

1401

//

1401

//

1402

1403

int reiserfs_init_locked_inode(struct inode *inode, void *p)

1403

int reiserfs_init_locked_inode(struct inode *inode, void *p)

1404

{

1404

{

1405

struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;

1405

struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;

1406

inode->i_ino = args->objectid;

1406

inode->i_ino = args->objectid;

1407

INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);

1407

INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);

1408

return 0;

1408

return 0;

1409

}

1409

}

1410

1411

/* looks for stat data in the tree, and fills up the fields of in-core

1411

/* looks for stat data in the tree, and fills up the fields of in-core

1412

inode stat data fields */

1412

inode stat data fields */

1413

void reiserfs_read_locked_inode(struct inode *inode,

1413

void reiserfs_read_locked_inode(struct inode *inode,

1414

struct reiserfs_iget_args *args)

1414

struct reiserfs_iget_args *args)

1415

{

1415

{

1416

INITIALIZE_PATH(path_to_sd);

1416

INITIALIZE_PATH(path_to_sd);

1417

struct cpu_key key;

1417

struct cpu_key key;

1418

unsigned long dirino;

1418

unsigned long dirino;

1419

int retval;

1419

int retval;

1420

1421

dirino = args->dirid;

1421

dirino = args->dirid;

1422

1423

/* set version 1, version 2 could be used too, because stat data

1423

/* set version 1, version 2 could be used too, because stat data

1424

key is the same in both versions */

1424

key is the same in both versions */

1425

key.version = KEY_FORMAT_3_5;

1425

key.version = KEY_FORMAT_3_5;

1426

key.on_disk_key.k_dir_id = dirino;

1426

key.on_disk_key.k_dir_id = dirino;

1427

key.on_disk_key.k_objectid = inode->i_ino;

1427

key.on_disk_key.k_objectid = inode->i_ino;

1428

key.on_disk_key.k_offset = 0;

1428

key.on_disk_key.k_offset = 0;

1429

key.on_disk_key.k_type = 0;

1429

key.on_disk_key.k_type = 0;

1430

1431

/* look for the object's stat data */

1431

/* look for the object's stat data */

1432

retval = search_item(inode->i_sb, &key, &path_to_sd);

1432

retval = search_item(inode->i_sb, &key, &path_to_sd);

1433

if (retval == IO_ERROR) {

1433

if (retval == IO_ERROR) {

1434

reiserfs_warning(inode->i_sb,

1434

reiserfs_warning(inode->i_sb,

1435

"vs-13070: reiserfs_read_locked_inode: "

1435

"vs-13070: reiserfs_read_locked_inode: "

1436

"i/o failure occurred trying to find stat data of %K",

1436

"i/o failure occurred trying to find stat data of %K",

1437

&key);

1437

&key);

1438

reiserfs_make_bad_inode(inode);

1438

reiserfs_make_bad_inode(inode);

1439

return;

1439

return;

1440

}

1440

}

1441

if (retval != ITEM_FOUND) {

1441

if (retval != ITEM_FOUND) {

1442

/* a stale NFS handle can trigger this without it being an error */

1442

/* a stale NFS handle can trigger this without it being an error */

1443

pathrelse(&path_to_sd);

1443

pathrelse(&path_to_sd);

1444

reiserfs_make_bad_inode(inode);

1444

reiserfs_make_bad_inode(inode);

1445

inode->i_nlink = 0;

1445

inode->i_nlink = 0;

1446

return;

1446

return;

1447

}

1447

}

1448

1449

init_inode(inode, &path_to_sd);

1449

init_inode(inode, &path_to_sd);

1450

1451

/* It is possible that knfsd is trying to access inode of a file

1451

/* It is possible that knfsd is trying to access inode of a file

1452

that is being removed from the disk by some other thread. As we

1452

that is being removed from the disk by some other thread. As we

1453

update sd on unlink all that is required is to check for nlink

1453

update sd on unlink all that is required is to check for nlink

1454

here. This bug was first found by Sizif when debugging

1454

here. This bug was first found by Sizif when debugging

1455

SquidNG/Butterfly, forgotten, and found again after Philippe

1455

SquidNG/Butterfly, forgotten, and found again after Philippe

1456

Gramoulle <philippe.gramoulle@mmania.com> reproduced it.

1456

Gramoulle <philippe.gramoulle@mmania.com> reproduced it.

1457

1458

More logical fix would require changes in fs/inode.c:iput() to

1458

More logical fix would require changes in fs/inode.c:iput() to

1459

remove inode from hash-table _after_ fs cleaned disk stuff up and

1459

remove inode from hash-table _after_ fs cleaned disk stuff up and

1460

in iget() to return NULL if I_FREEING inode is found in

1460

in iget() to return NULL if I_FREEING inode is found in

1461

hash-table. */

1461

hash-table. */

1462

/* Currently there is one place where it's ok to meet inode with

1462

/* Currently there is one place where it's ok to meet inode with

1463

nlink==0: processing of open-unlinked and half-truncated files

1463

nlink==0: processing of open-unlinked and half-truncated files

1464

during mount (fs/reiserfs/super.c:finish_unfinished()). */

1464

during mount (fs/reiserfs/super.c:finish_unfinished()). */

1465

if ((inode->i_nlink == 0) &&

1465

if ((inode->i_nlink == 0) &&

1466

!REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {

1466

!REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {

1467

reiserfs_warning(inode->i_sb,

1467

reiserfs_warning(inode->i_sb,

1468

"vs-13075: reiserfs_read_locked_inode: "

1468

"vs-13075: reiserfs_read_locked_inode: "

1469

"dead inode read from disk %K. "

1469

"dead inode read from disk %K. "

1470

"This is likely to be race with knfsd. Ignore",

1470

"This is likely to be race with knfsd. Ignore",

1471

&key);

1471

&key);

1472

reiserfs_make_bad_inode(inode);

1472

reiserfs_make_bad_inode(inode);

1473

}

1473

}

1474

1475

reiserfs_check_path(&path_to_sd); /* init inode should be relsing */

1475

reiserfs_check_path(&path_to_sd); /* init inode should be relsing */

1476

1477

}

1477

}

1478

1479

/**

1479

/**

1480

* reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().

1480

* reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().

1481

*

1481

*

1482

* @inode: inode from hash table to check

1482

* @inode: inode from hash table to check

1483

* @opaque: "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.

1483

* @opaque: "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.

1484

*

1484

*

1485

* This function is called by iget5_locked() to distinguish reiserfs inodes

1485

* This function is called by iget5_locked() to distinguish reiserfs inodes

1486

* having the same inode numbers. Such inodes can only exist due to some

1486

* having the same inode numbers. Such inodes can only exist due to some

1487

* error condition. One of them should be bad. Inodes with identical

1487

* error condition. One of them should be bad. Inodes with identical

1488

* inode numbers (objectids) are distinguished by parent directory ids.

1488

* inode numbers (objectids) are distinguished by parent directory ids.

1489

*

1489

*

1490

*/

1490

*/

1491

int reiserfs_find_actor(struct inode *inode, void *opaque)

1491

int reiserfs_find_actor(struct inode *inode, void *opaque)

1492

{

1492

{

1493

struct reiserfs_iget_args *args;

1493

struct reiserfs_iget_args *args;

1494

1495

args = opaque;

1495

args = opaque;

1496

/* args is already in CPU order */

1496

/* args is already in CPU order */

1497

return (inode->i_ino == args->objectid) &&

1497

return (inode->i_ino == args->objectid) &&

1498

(le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);

1498

(le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);

1499

}

1499

}

1500

1501

struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)

1501

struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)

1502

{

1502

{

1503

struct inode *inode;

1503

struct inode *inode;

1504

struct reiserfs_iget_args args;

1504

struct reiserfs_iget_args args;

1505

1506

args.objectid = key->on_disk_key.k_objectid;

1506

args.objectid = key->on_disk_key.k_objectid;

1507

args.dirid = key->on_disk_key.k_dir_id;

1507

args.dirid = key->on_disk_key.k_dir_id;

1508

inode = iget5_locked(s, key->on_disk_key.k_objectid,

1508

inode = iget5_locked(s, key->on_disk_key.k_objectid,

1509

reiserfs_find_actor, reiserfs_init_locked_inode,

1509

reiserfs_find_actor, reiserfs_init_locked_inode,

1510

(void *)(&args));

1510

(void *)(&args));

1511

if (!inode)

1511

if (!inode)

1512

return ERR_PTR(-ENOMEM);

1512

return ERR_PTR(-ENOMEM);

1513

1514

if (inode->i_state & I_NEW) {

1514

if (inode->i_state & I_NEW) {

1515

reiserfs_read_locked_inode(inode, &args);

1515

reiserfs_read_locked_inode(inode, &args);

1516

unlock_new_inode(inode);

1516

unlock_new_inode(inode);

1517

}

1517

}

1518

1519

if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {

1519

if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {

1520

/* either due to i/o error or a stale NFS handle */

1520

/* either due to i/o error or a stale NFS handle */

1521

iput(inode);

1521

iput(inode);

1522

inode = NULL;

1522

inode = NULL;

1523

}

1523

}

1524

return inode;

1524

return inode;

1525

}

1525

}

1526

1527

struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp)

1527

struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp)

1528

{

1528

{

1529

__u32 *data = vobjp;

1529

__u32 *data = vobjp;

1530

struct cpu_key key;

1530

struct cpu_key key;

1531

struct dentry *result;

1531

struct dentry *result;

1532

struct inode *inode;

1532

struct inode *inode;

1533

1534

key.on_disk_key.k_objectid = data[0];

1534

key.on_disk_key.k_objectid = data[0];

1535

key.on_disk_key.k_dir_id = data[1];

1535

key.on_disk_key.k_dir_id = data[1];

1536

reiserfs_write_lock(sb);

1536

reiserfs_write_lock(sb);

1537

inode = reiserfs_iget(sb, &key);

1537

inode = reiserfs_iget(sb, &key);

1538

if (inode && !IS_ERR(inode) && data[2] != 0 &&

1538

if (inode && !IS_ERR(inode) && data[2] != 0 &&

1539

data[2] != inode->i_generation) {

1539

data[2] != inode->i_generation) {

1540

iput(inode);

1540

iput(inode);

1541

inode = NULL;

1541

inode = NULL;

1542

}

1542

}

1543

reiserfs_write_unlock(sb);

1543

reiserfs_write_unlock(sb);

1544

if (!inode)

1544

if (!inode)

1545

inode = ERR_PTR(-ESTALE);

1545

inode = ERR_PTR(-ESTALE);

1546

if (IS_ERR(inode))

1546

if (IS_ERR(inode))

1547

return ERR_PTR(PTR_ERR(inode));

1547

return ERR_PTR(PTR_ERR(inode));

1548

result = d_alloc_anon(inode);

1548

result = d_alloc_anon(inode);

1549

if (!result) {

1549

if (!result) {

1550

iput(inode);

1550

iput(inode);

1551

return ERR_PTR(-ENOMEM);

1551

return ERR_PTR(-ENOMEM);

1552

}

1552

}

1553

return result;

1553

return result;

1554

}

1554

}

1555

1556

struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,

1556

struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,

1557

int len, int fhtype,

1557

int len, int fhtype,

1558

int (*acceptable) (void *contect,

1558

int (*acceptable) (void *contect,

1559

struct dentry * de),

1559

struct dentry * de),

1560

void *context)

1560

void *context)

1561

{

1561

{

1562

__u32 obj[3], parent[3];

1562

__u32 obj[3], parent[3];

1563

1564

/* fhtype happens to reflect the number of u32s encoded.

1564

/* fhtype happens to reflect the number of u32s encoded.

1565

* due to a bug in earlier code, fhtype might indicate there

1565

* due to a bug in earlier code, fhtype might indicate there

1566

* are more u32s then actually fitted.

1566

* are more u32s then actually fitted.

1567

* so if fhtype seems to be more than len, reduce fhtype.

1567

* so if fhtype seems to be more than len, reduce fhtype.

1568

* Valid types are:

1568

* Valid types are:

1569

* 2 - objectid + dir_id - legacy support

1569

* 2 - objectid + dir_id - legacy support

1570

* 3 - objectid + dir_id + generation

1570

* 3 - objectid + dir_id + generation

1571

* 4 - objectid + dir_id + objectid and dirid of parent - legacy

1571

* 4 - objectid + dir_id + objectid and dirid of parent - legacy

1572

* 5 - objectid + dir_id + generation + objectid and dirid of parent

1572

* 5 - objectid + dir_id + generation + objectid and dirid of parent

1573

* 6 - as above plus generation of directory

1573

* 6 - as above plus generation of directory

1574

* 6 does not fit in NFSv2 handles

1574

* 6 does not fit in NFSv2 handles

1575

*/

1575

*/

1576

if (fhtype > len) {

1576

if (fhtype > len) {

1577

if (fhtype != 6 || len != 5)

1577

if (fhtype != 6 || len != 5)

1578

reiserfs_warning(sb,

1578

reiserfs_warning(sb,

1579

"nfsd/reiserfs, fhtype=%d, len=%d - odd",

1579

"nfsd/reiserfs, fhtype=%d, len=%d - odd",

1580

fhtype, len);

1580

fhtype, len);

1581

fhtype = 5;

1581

fhtype = 5;

1582

}

1582

}

1583

1584

obj[0] = data[0];

1584

obj[0] = data[0];

1585

obj[1] = data[1];

1585

obj[1] = data[1];

1586

if (fhtype == 3 || fhtype >= 5)

1586

if (fhtype == 3 || fhtype >= 5)

1587

obj[2] = data[2];

1587

obj[2] = data[2];

1588

else

1588

else

1589

obj[2] = 0; /* generation number */

1589

obj[2] = 0; /* generation number */

1590

1591

if (fhtype >= 4) {

1591

if (fhtype >= 4) {

1592

parent[0] = data[fhtype >= 5 ? 3 : 2];

1592

parent[0] = data[fhtype >= 5 ? 3 : 2];

1593

parent[1] = data[fhtype >= 5 ? 4 : 3];

1593

parent[1] = data[fhtype >= 5 ? 4 : 3];

1594

if (fhtype == 6)

1594

if (fhtype == 6)

1595

parent[2] = data[5];

1595

parent[2] = data[5];

1596

else

1596

else

1597

parent[2] = 0;

1597

parent[2] = 0;

1598

}

1598

}

1599

return sb->s_export_op->find_exported_dentry(sb, obj,

1599

return sb->s_export_op->find_exported_dentry(sb, obj,

1600

fhtype < 4 ? NULL : parent,

1600

fhtype < 4 ? NULL : parent,

1601

acceptable, context);

1601

acceptable, context);

1602

}

1602

}

1603

1604

int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,

1604

int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,

1605

int need_parent)

1605

int need_parent)

1606

{

1606

{

1607

struct inode *inode = dentry->d_inode;

1607

struct inode *inode = dentry->d_inode;

1608

int maxlen = *lenp;

1608

int maxlen = *lenp;

1609

1610

if (maxlen < 3)

1610

if (maxlen < 3)

1611

return 255;

1611

return 255;

1612

1613

data[0] = inode->i_ino;

1613

data[0] = inode->i_ino;

1614

data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1614

data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1615

data[2] = inode->i_generation;

1615

data[2] = inode->i_generation;

1616

*lenp = 3;

1616

*lenp = 3;

1617

/* no room for directory info? return what we've stored so far */

1617

/* no room for directory info? return what we've stored so far */

1618

if (maxlen < 5 || !need_parent)

1618

if (maxlen < 5 || !need_parent)

1619

return 3;

1619

return 3;

1620

1621

spin_lock(&dentry->d_lock);

1621

spin_lock(&dentry->d_lock);

1622

inode = dentry->d_parent->d_inode;

1622

inode = dentry->d_parent->d_inode;

1623

data[3] = inode->i_ino;

1623

data[3] = inode->i_ino;

1624

data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1624

data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);

1625

*lenp = 5;

1625

*lenp = 5;

1626

if (maxlen >= 6) {

1626

if (maxlen >= 6) {

1627

data[5] = inode->i_generation;

1627

data[5] = inode->i_generation;

1628

*lenp = 6;

1628

*lenp = 6;

1629

}

1629

}

1630

spin_unlock(&dentry->d_lock);

1630

spin_unlock(&dentry->d_lock);

1631

return *lenp;

1631

return *lenp;

1632

}

1632

}

1633

1634

/* looks for stat data, then copies fields to it, marks the buffer

1634

/* looks for stat data, then copies fields to it, marks the buffer

1635

containing stat data as dirty */

1635

containing stat data as dirty */

1636

/* reiserfs inodes are never really dirty, since the dirty inode call

1636

/* reiserfs inodes are never really dirty, since the dirty inode call

1637

** always logs them. This call allows the VFS inode marking routines

1637

** always logs them. This call allows the VFS inode marking routines

1638

** to properly mark inodes for datasync and such, but only actually

1638

** to properly mark inodes for datasync and such, but only actually

1639

** does something when called for a synchronous update.

1639

** does something when called for a synchronous update.

1640

*/

1640

*/

1641

int reiserfs_write_inode(struct inode *inode, int do_sync)

1641

int reiserfs_write_inode(struct inode *inode, int do_sync)

1642

{

1642

{

1643

struct reiserfs_transaction_handle th;

1643

struct reiserfs_transaction_handle th;

1644

int jbegin_count = 1;

1644

int jbegin_count = 1;

1645

1646

if (inode->i_sb->s_flags & MS_RDONLY)

1646

if (inode->i_sb->s_flags & MS_RDONLY)

1647

return -EROFS;

1647

return -EROFS;

1648

/* memory pressure can sometimes initiate write_inode calls with sync == 1,

1648

/* memory pressure can sometimes initiate write_inode calls with sync == 1,

1649

** these cases are just when the system needs ram, not when the

1649

** these cases are just when the system needs ram, not when the

1650

** inode needs to reach disk for safety, and they can safely be

1650

** inode needs to reach disk for safety, and they can safely be

1651

** ignored because the altered inode has already been logged.

1651

** ignored because the altered inode has already been logged.

1652

*/

1652

*/

1653

if (do_sync && !(current->flags & PF_MEMALLOC)) {

1653

if (do_sync && !(current->flags & PF_MEMALLOC)) {

1654

reiserfs_write_lock(inode->i_sb);

1654

reiserfs_write_lock(inode->i_sb);

1655

if (!journal_begin(&th, inode->i_sb, jbegin_count)) {

1655

if (!journal_begin(&th, inode->i_sb, jbegin_count)) {

1656

reiserfs_update_sd(&th, inode);

1656

reiserfs_update_sd(&th, inode);

1657

journal_end_sync(&th, inode->i_sb, jbegin_count);

1657

journal_end_sync(&th, inode->i_sb, jbegin_count);

1658

}

1658

}

1659

reiserfs_write_unlock(inode->i_sb);

1659

reiserfs_write_unlock(inode->i_sb);

1660

}

1660

}

1661

return 0;

1661

return 0;

1662

}

1662

}

1663

1664

/* stat data of new object is inserted already, this inserts the item

1664

/* stat data of new object is inserted already, this inserts the item

1665

containing "." and ".." entries */

1665

containing "." and ".." entries */

1666

static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,

1666

static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,

1667

struct inode *inode,

1667

struct inode *inode,

1668

struct item_head *ih, struct path *path,

1668

struct item_head *ih, struct path *path,

1669

struct inode *dir)

1669

struct inode *dir)

1670

{

1670

{

1671

struct super_block *sb = th->t_super;

1671

struct super_block *sb = th->t_super;

1672

char empty_dir[EMPTY_DIR_SIZE];

1672

char empty_dir[EMPTY_DIR_SIZE];

1673

char *body = empty_dir;

1673

char *body = empty_dir;

1674

struct cpu_key key;

1674

struct cpu_key key;

1675

int retval;

1675

int retval;

1676

1677

BUG_ON(!th->t_trans_id);

1677

BUG_ON(!th->t_trans_id);

1678

1679

_make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),

1679

_make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),

1680

le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,

1680

le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,

1681

TYPE_DIRENTRY, 3 /*key length */ );

1681

TYPE_DIRENTRY, 3 /*key length */ );

1682

1683

/* compose item head for new item. Directories consist of items of

1683

/* compose item head for new item. Directories consist of items of

1684

old type (ITEM_VERSION_1). Do not set key (second arg is 0), it

1684

old type (ITEM_VERSION_1). Do not set key (second arg is 0), it

1685

is done by reiserfs_new_inode */

1685

is done by reiserfs_new_inode */

1686

if (old_format_only(sb)) {

1686

if (old_format_only(sb)) {

1687

make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,

1687

make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,

1688

TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);

1688

TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);

1689

1690

make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,

1690

make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,

1691

ih->ih_key.k_objectid,

1691

ih->ih_key.k_objectid,

1692

INODE_PKEY(dir)->k_dir_id,

1692

INODE_PKEY(dir)->k_dir_id,

1693

INODE_PKEY(dir)->k_objectid);

1693

INODE_PKEY(dir)->k_objectid);

1694

} else {

1694

} else {

1695

make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,

1695

make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,

1696

TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);

1696

TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);

1697

1698

make_empty_dir_item(body, ih->ih_key.k_dir_id,

1698

make_empty_dir_item(body, ih->ih_key.k_dir_id,

1699

ih->ih_key.k_objectid,

1699

ih->ih_key.k_objectid,

1700

INODE_PKEY(dir)->k_dir_id,

1700

INODE_PKEY(dir)->k_dir_id,

1701

INODE_PKEY(dir)->k_objectid);

1701

INODE_PKEY(dir)->k_objectid);

1702

}

1702

}

1703

1704

/* look for place in the tree for new item */

1704

/* look for place in the tree for new item */

1705

retval = search_item(sb, &key, path);

1705

retval = search_item(sb, &key, path);

1706

if (retval == IO_ERROR) {

1706

if (retval == IO_ERROR) {

1707

reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "

1707

reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "

1708

"i/o failure occurred creating new directory");

1708

"i/o failure occurred creating new directory");

1709

return -EIO;

1709

return -EIO;

1710

}

1710

}

1711

if (retval == ITEM_FOUND) {

1711

if (retval == ITEM_FOUND) {

1712

pathrelse(path);

1712

pathrelse(path);

1713

reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "

1713

reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "

1714

"object with this key exists (%k)",

1714

"object with this key exists (%k)",

1715

&(ih->ih_key));

1715

&(ih->ih_key));

1716

return -EEXIST;

1716

return -EEXIST;

1717

}

1717

}

1718

1719

/* insert item, that is empty directory item */

1719

/* insert item, that is empty directory item */

1720

return reiserfs_insert_item(th, path, &key, ih, inode, body);

1720

return reiserfs_insert_item(th, path, &key, ih, inode, body);

1721

}

1721

}

1722

1723

/* stat data of object has been inserted, this inserts the item

1723

/* stat data of object has been inserted, this inserts the item

1724

containing the body of symlink */

1724

containing the body of symlink */

1725

static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode of symlink */

1725

static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode of symlink */

1726

struct item_head *ih,

1726

struct item_head *ih,

1727

struct path *path, const char *symname,

1727

struct path *path, const char *symname,

1728

int item_len)

1728

int item_len)

1729

{

1729

{

1730

struct super_block *sb = th->t_super;

1730

struct super_block *sb = th->t_super;

1731

struct cpu_key key;

1731

struct cpu_key key;

1732

int retval;

1732

int retval;

1733

1734

BUG_ON(!th->t_trans_id);

1734

BUG_ON(!th->t_trans_id);

1735

1736

_make_cpu_key(&key, KEY_FORMAT_3_5,

1736

_make_cpu_key(&key, KEY_FORMAT_3_5,

1737

le32_to_cpu(ih->ih_key.k_dir_id),

1737

le32_to_cpu(ih->ih_key.k_dir_id),

1738

le32_to_cpu(ih->ih_key.k_objectid),

1738

le32_to_cpu(ih->ih_key.k_objectid),

1739

1, TYPE_DIRECT, 3 /*key length */ );

1739

1, TYPE_DIRECT, 3 /*key length */ );

1740

1741

make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,

1741

make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,

1742

0 /*free_space */ );

1742

0 /*free_space */ );

1743

1744

/* look for place in the tree for new item */

1744

/* look for place in the tree for new item */

1745

retval = search_item(sb, &key, path);

1745

retval = search_item(sb, &key, path);

1746

if (retval == IO_ERROR) {

1746

if (retval == IO_ERROR) {

1747

reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "

1747

reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "

1748

"i/o failure occurred creating new symlink");

1748

"i/o failure occurred creating new symlink");

1749

return -EIO;

1749

return -EIO;

1750

}

1750

}

1751

if (retval == ITEM_FOUND) {

1751

if (retval == ITEM_FOUND) {

1752

pathrelse(path);

1752

pathrelse(path);

1753

reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "

1753

reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "

1754

"object with this key exists (%k)",

1754

"object with this key exists (%k)",

1755

&(ih->ih_key));

1755

&(ih->ih_key));

1756

return -EEXIST;

1756

return -EEXIST;

1757

}

1757

}

1758

1759

/* insert item, that is body of symlink */

1759

/* insert item, that is body of symlink */

1760

return reiserfs_insert_item(th, path, &key, ih, inode, symname);

1760

return reiserfs_insert_item(th, path, &key, ih, inode, symname);

1761

}

1761

}

1762

1763

/* inserts the stat data into the tree, and then calls

1763

/* inserts the stat data into the tree, and then calls

1764

reiserfs_new_directory (to insert ".", ".." item if new object is

1764

reiserfs_new_directory (to insert ".", ".." item if new object is

1765

directory) or reiserfs_new_symlink (to insert symlink body if new

1765

directory) or reiserfs_new_symlink (to insert symlink body if new

1766

object is symlink) or nothing (if new object is regular file)

1766

object is symlink) or nothing (if new object is regular file)

1767

1768

NOTE! uid and gid must already be set in the inode. If we return

1768

NOTE! uid and gid must already be set in the inode. If we return

1769

non-zero due to an error, we have to drop the quota previously allocated

1769

non-zero due to an error, we have to drop the quota previously allocated

1770

for the fresh inode. This can only be done outside a transaction, so

1770

for the fresh inode. This can only be done outside a transaction, so

1771

if we return non-zero, we also end the transaction. */

1771

if we return non-zero, we also end the transaction. */

1772

int reiserfs_new_inode(struct reiserfs_transaction_handle *th,

1772

int reiserfs_new_inode(struct reiserfs_transaction_handle *th,

1773

struct inode *dir, int mode, const char *symname,

1773

struct inode *dir, int mode, const char *symname,

1774

/* 0 for regular, EMTRY_DIR_SIZE for dirs,

1774

/* 0 for regular, EMTRY_DIR_SIZE for dirs,

1775

strlen (symname) for symlinks) */

1775

strlen (symname) for symlinks) */

1776

loff_t i_size, struct dentry *dentry,

1776

loff_t i_size, struct dentry *dentry,

1777

struct inode *inode)

1777

struct inode *inode)

1778

{

1778

{

1779

struct super_block *sb;

1779

struct super_block *sb;

1780

INITIALIZE_PATH(path_to_key);

1780

INITIALIZE_PATH(path_to_key);

1781

struct cpu_key key;

1781

struct cpu_key key;

1782

struct item_head ih;

1782

struct item_head ih;

1783

struct stat_data sd;

1783

struct stat_data sd;

1784

int retval;

1784

int retval;

1785

int err;

1785

int err;

1786

1787

BUG_ON(!th->t_trans_id);

1787

BUG_ON(!th->t_trans_id);

1788

1789

if (DQUOT_ALLOC_INODE(inode)) {

1789

if (DQUOT_ALLOC_INODE(inode)) {

1790

err = -EDQUOT;

1790

err = -EDQUOT;

1791

goto out_end_trans;

1791

goto out_end_trans;

1792

}

1792

}

1793

if (!dir || !dir->i_nlink) {

1793

if (!dir || !dir->i_nlink) {

1794

err = -EPERM;

1794

err = -EPERM;

1795

goto out_bad_inode;

1795

goto out_bad_inode;

1796

}

1796

}

1797

1798

sb = dir->i_sb;

1798

sb = dir->i_sb;

1799

1800

/* item head of new item */

1800

/* item head of new item */

1801

ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);

1801

ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);

1802

ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));

1802

ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));

1803

if (!ih.ih_key.k_objectid) {

1803

if (!ih.ih_key.k_objectid) {

1804

err = -ENOMEM;

1804

err = -ENOMEM;

1805

goto out_bad_inode;

1805

goto out_bad_inode;

1806

}

1806

}

1807

if (old_format_only(sb))

1807

if (old_format_only(sb))

1808

/* not a perfect generation count, as object ids can be reused, but

1808

/* not a perfect generation count, as object ids can be reused, but

1809

** this is as good as reiserfs can do right now.

1809

** this is as good as reiserfs can do right now.

1810

** note that the private part of inode isn't filled in yet, we have

1810

** note that the private part of inode isn't filled in yet, we have

1811

** to use the directory.

1811

** to use the directory.

1812

*/

1812

*/

1813

inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);

1813

inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);

1814

else

1814

else

1815

#if defined( USE_INODE_GENERATION_COUNTER )

1815

#if defined( USE_INODE_GENERATION_COUNTER )

1816

inode->i_generation =

1816

inode->i_generation =

1817

le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);

1817

le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);

1818

#else

1818

#else

1819

inode->i_generation = ++event;

1819

inode->i_generation = ++event;

1820

#endif

1820

#endif

1821

1822

/* fill stat data */

1822

/* fill stat data */

1823

inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);

1823

inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);

1824

1825

/* uid and gid must already be set by the caller for quota init */

1825

/* uid and gid must already be set by the caller for quota init */

1826

1827

/* symlink cannot be immutable or append only, right? */

1827

/* symlink cannot be immutable or append only, right? */

1828

if (S_ISLNK(inode->i_mode))

1828

if (S_ISLNK(inode->i_mode))

1829

inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);

1829

inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);

1830

1831

inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;

1831

inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;

1832

inode->i_size = i_size;

1832

inode->i_size = i_size;

1833

inode->i_blocks = 0;

1833

inode->i_blocks = 0;

1834

inode->i_bytes = 0;

1834

inode->i_bytes = 0;

1835

REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :

1835

REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :

1836

U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;

1836

U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;

1837

1838

INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));

1838

INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));

1839

REISERFS_I(inode)->i_flags = 0;

1839

REISERFS_I(inode)->i_flags = 0;

1840

REISERFS_I(inode)->i_prealloc_block = 0;

1840

REISERFS_I(inode)->i_prealloc_block = 0;

1841

REISERFS_I(inode)->i_prealloc_count = 0;

1841

REISERFS_I(inode)->i_prealloc_count = 0;

1842

REISERFS_I(inode)->i_trans_id = 0;

1842

REISERFS_I(inode)->i_trans_id = 0;

1843

REISERFS_I(inode)->i_jl = NULL;

1843

REISERFS_I(inode)->i_jl = NULL;

1844

REISERFS_I(inode)->i_attrs =

1844

REISERFS_I(inode)->i_attrs =

1845

REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;

1845

REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;

1846

sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);

1846

sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);

1847

REISERFS_I(inode)->i_acl_access = NULL;

1847

REISERFS_I(inode)->i_acl_access = NULL;

1848

REISERFS_I(inode)->i_acl_default = NULL;

1848

REISERFS_I(inode)->i_acl_default = NULL;

1849

init_rwsem(&REISERFS_I(inode)->xattr_sem);

1849

init_rwsem(&REISERFS_I(inode)->xattr_sem);

1850

1851

if (old_format_only(sb))

1851

if (old_format_only(sb))

1852

make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,

1852

make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,

1853

TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);

1853

TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);

1854

else

1854

else

1855

make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,

1855

make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,

1856

TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);

1856

TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);

1857

1858

/* key to search for correct place for new stat data */

1858

/* key to search for correct place for new stat data */

1859

_make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),

1859

_make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),

1860

le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,

1860

le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,

1861

TYPE_STAT_DATA, 3 /*key length */ );

1861

TYPE_STAT_DATA, 3 /*key length */ );

1862

1863

/* find proper place for inserting of stat data */

1863

/* find proper place for inserting of stat data */

1864

retval = search_item(sb, &key, &path_to_key);

1864

retval = search_item(sb, &key, &path_to_key);

1865

if (retval == IO_ERROR) {

1865

if (retval == IO_ERROR) {

1866

err = -EIO;

1866

err = -EIO;

1867

goto out_bad_inode;

1867

goto out_bad_inode;

1868

}

1868

}

1869

if (retval == ITEM_FOUND) {

1869

if (retval == ITEM_FOUND) {

1870

pathrelse(&path_to_key);

1870

pathrelse(&path_to_key);

1871

err = -EEXIST;

1871

err = -EEXIST;

1872

goto out_bad_inode;

1872

goto out_bad_inode;

1873

}

1873

}

1874

if (old_format_only(sb)) {

1874

if (old_format_only(sb)) {

1875

if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {

1875

if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {

1876

pathrelse(&path_to_key);

1876

pathrelse(&path_to_key);

1877

/* i_uid or i_gid is too big to be stored in stat data v3.5 */

1877

/* i_uid or i_gid is too big to be stored in stat data v3.5 */

1878

err = -EINVAL;

1878

err = -EINVAL;

1879

goto out_bad_inode;

1879

goto out_bad_inode;

1880

}

1880

}

1881

inode2sd_v1(&sd, inode, inode->i_size);

1881

inode2sd_v1(&sd, inode, inode->i_size);

1882

} else {

1882

} else {

1883

inode2sd(&sd, inode, inode->i_size);

1883

inode2sd(&sd, inode, inode->i_size);

1884

}

1884

}

1885

// these do not go to on-disk stat data

1885

// these do not go to on-disk stat data

1886

inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);

1886

inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);

1887

inode->i_blksize = reiserfs_default_io_size;

1887

inode->i_blksize = reiserfs_default_io_size;

1888

1889

// store in in-core inode the key of stat data and version all

1889

// store in in-core inode the key of stat data and version all

1890

// object items will have (directory items will have old offset

1890

// object items will have (directory items will have old offset

1891

// format, other new objects will consist of new items)

1891

// format, other new objects will consist of new items)

1892

memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);

1892

memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);

1893

if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))

1893

if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))

1894

set_inode_item_key_version(inode, KEY_FORMAT_3_5);

1894

set_inode_item_key_version(inode, KEY_FORMAT_3_5);

1895

else

1895

else

1896

set_inode_item_key_version(inode, KEY_FORMAT_3_6);

1896

set_inode_item_key_version(inode, KEY_FORMAT_3_6);

1897

if (old_format_only(sb))

1897

if (old_format_only(sb))

1898

set_inode_sd_version(inode, STAT_DATA_V1);

1898

set_inode_sd_version(inode, STAT_DATA_V1);

1899

else

1899

else

1900

set_inode_sd_version(inode, STAT_DATA_V2);

1900

set_inode_sd_version(inode, STAT_DATA_V2);

1901

1902

/* insert the stat data into the tree */

1902

/* insert the stat data into the tree */

1903

#ifdef DISPLACE_NEW_PACKING_LOCALITIES

1903

#ifdef DISPLACE_NEW_PACKING_LOCALITIES

1904

if (REISERFS_I(dir)->new_packing_locality)

1904

if (REISERFS_I(dir)->new_packing_locality)

1905

th->displace_new_blocks = 1;

1905

th->displace_new_blocks = 1;

1906

#endif

1906

#endif

1907

retval =

1907

retval =

1908

reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,

1908

reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,

1909

(char *)(&sd));

1909

(char *)(&sd));

1910

if (retval) {

1910

if (retval) {

1911

err = retval;

1911

err = retval;

1912

reiserfs_check_path(&path_to_key);

1912

reiserfs_check_path(&path_to_key);

1913

goto out_bad_inode;

1913

goto out_bad_inode;

1914

}

1914

}

1915

#ifdef DISPLACE_NEW_PACKING_LOCALITIES

1915

#ifdef DISPLACE_NEW_PACKING_LOCALITIES

1916

if (!th->displace_new_blocks)

1916

if (!th->displace_new_blocks)

1917

REISERFS_I(dir)->new_packing_locality = 0;

1917

REISERFS_I(dir)->new_packing_locality = 0;

1918

#endif

1918

#endif

1919

if (S_ISDIR(mode)) {

1919

if (S_ISDIR(mode)) {

1920

/* insert item with "." and ".." */

1920

/* insert item with "." and ".." */

1921

retval =

1921

retval =

1922

reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);

1922

reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);

1923

}

1923

}

1924

1925

if (S_ISLNK(mode)) {

1925

if (S_ISLNK(mode)) {

1926

/* insert body of symlink */

1926

/* insert body of symlink */

1927

if (!old_format_only(sb))

1927

if (!old_format_only(sb))

1928

i_size = ROUND_UP(i_size);

1928

i_size = ROUND_UP(i_size);

1929

retval =

1929

retval =

1930

reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,

1930

reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,

1931

i_size);

1931

i_size);

1932

}

1932

}

1933

if (retval) {

1933

if (retval) {

1934

err = retval;

1934

err = retval;

1935

reiserfs_check_path(&path_to_key);

1935

reiserfs_check_path(&path_to_key);

1936

journal_end(th, th->t_super, th->t_blocks_allocated);

1936

journal_end(th, th->t_super, th->t_blocks_allocated);

1937

goto out_inserted_sd;

1937

goto out_inserted_sd;

1938

}

1938

}

1939

1940

/* XXX CHECK THIS */

1940

/* XXX CHECK THIS */

1941

if (reiserfs_posixacl(inode->i_sb)) {

1941

if (reiserfs_posixacl(inode->i_sb)) {

1942

retval = reiserfs_inherit_default_acl(dir, dentry, inode);

1942

retval = reiserfs_inherit_default_acl(dir, dentry, inode);

1943

if (retval) {

1943

if (retval) {

1944

err = retval;

1944

err = retval;

1945

reiserfs_check_path(&path_to_key);

1945

reiserfs_check_path(&path_to_key);

1946

journal_end(th, th->t_super, th->t_blocks_allocated);

1946

journal_end(th, th->t_super, th->t_blocks_allocated);

1947

goto out_inserted_sd;

1947

goto out_inserted_sd;

1948

}

1948

}

1949

} else if (inode->i_sb->s_flags & MS_POSIXACL) {

1949

} else if (inode->i_sb->s_flags & MS_POSIXACL) {

1950

reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "

1950

reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "

1951

"but vfs thinks they are!");

1951

"but vfs thinks they are!");

1952

} else if (is_reiserfs_priv_object(dir)) {

1952

} else if (is_reiserfs_priv_object(dir)) {

1953

reiserfs_mark_inode_private(inode);

1953

reiserfs_mark_inode_private(inode);

1954

}

1954

}

1955

1956

insert_inode_hash(inode);

1956

insert_inode_hash(inode);

1957

reiserfs_update_sd(th, inode);

1957

reiserfs_update_sd(th, inode);

1958

reiserfs_check_path(&path_to_key);

1958

reiserfs_check_path(&path_to_key);

1959

1960

return 0;

1960

return 0;

1961

1962

/* it looks like you can easily compress these two goto targets into

1962

/* it looks like you can easily compress these two goto targets into

1963

* one. Keeping it like this doesn't actually hurt anything, and they

1963

* one. Keeping it like this doesn't actually hurt anything, and they

1964

* are place holders for what the quota code actually needs.

1964

* are place holders for what the quota code actually needs.

1965

*/

1965

*/

1966

out_bad_inode:

1966

out_bad_inode:

1967

/* Invalidate the object, nothing was inserted yet */

1967

/* Invalidate the object, nothing was inserted yet */

1968

INODE_PKEY(inode)->k_objectid = 0;

1968

INODE_PKEY(inode)->k_objectid = 0;

1969

1970

/* Quota change must be inside a transaction for journaling */

1970

/* Quota change must be inside a transaction for journaling */

1971

DQUOT_FREE_INODE(inode);

1971

DQUOT_FREE_INODE(inode);

1972

1973

out_end_trans:

1973

out_end_trans:

1974

journal_end(th, th->t_super, th->t_blocks_allocated);

1974

journal_end(th, th->t_super, th->t_blocks_allocated);

1975

/* Drop can be outside and it needs more credits so it's better to have it outside */

1975

/* Drop can be outside and it needs more credits so it's better to have it outside */

1976

DQUOT_DROP(inode);

1976

DQUOT_DROP(inode);

1977

inode->i_flags |= S_NOQUOTA;

1977

inode->i_flags |= S_NOQUOTA;

1978

make_bad_inode(inode);

1978

make_bad_inode(inode);

1979

1980

out_inserted_sd:

1980

out_inserted_sd:

1981

inode->i_nlink = 0;

1981

inode->i_nlink = 0;

1982

th->t_trans_id = 0; /* so the caller can't use this handle later */

1982

th->t_trans_id = 0; /* so the caller can't use this handle later */

1983

1984

/* If we were inheriting an ACL, we need to release the lock so that

1984

/* If we were inheriting an ACL, we need to release the lock so that

1985

* iput doesn't deadlock in reiserfs_delete_xattrs. The locking

1985

* iput doesn't deadlock in reiserfs_delete_xattrs. The locking

1986

* code really needs to be reworked, but this will take care of it

1986

* code really needs to be reworked, but this will take care of it

1987

* for now. -jeffm */

1987

* for now. -jeffm */

1988

if (REISERFS_I(dir)->i_acl_default) {

1988

if (REISERFS_I(dir)->i_acl_default && !IS_ERR(REISERFS_I(dir)->i_acl_default)) {

1989

reiserfs_write_unlock_xattrs(dir->i_sb);

1989

reiserfs_write_unlock_xattrs(dir->i_sb);

1990

iput(inode);

1990

iput(inode);

1991

reiserfs_write_lock_xattrs(dir->i_sb);

1991

reiserfs_write_lock_xattrs(dir->i_sb);

1992

} else

1992

} else

1993

iput(inode);

1993

iput(inode);

1994

return err;

1994

return err;

1995

}

1995

}

1996

1997

/*

1997

/*

1998

** finds the tail page in the page cache,

1998

** finds the tail page in the page cache,

1999

** reads the last block in.

1999

** reads the last block in.

2000

**

2000

**

2001

** On success, page_result is set to a locked, pinned page, and bh_result

2001

** On success, page_result is set to a locked, pinned page, and bh_result

2002

** is set to an up to date buffer for the last block in the file. returns 0.

2002

** is set to an up to date buffer for the last block in the file. returns 0.

2003

**

2003

**

2004

** tail conversion is not done, so bh_result might not be valid for writing

2004

** tail conversion is not done, so bh_result might not be valid for writing

2005

** check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before

2005

** check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before

2006

** trying to write the block.

2006

** trying to write the block.

2007

**

2007

**

2008

** on failure, nonzero is returned, page_result and bh_result are untouched.

2008

** on failure, nonzero is returned, page_result and bh_result are untouched.

2009

*/

2009

*/

2010

static int grab_tail_page(struct inode *p_s_inode,

2010

static int grab_tail_page(struct inode *p_s_inode,

2011

struct page **page_result,

2011

struct page **page_result,

2012

struct buffer_head **bh_result)

2012

struct buffer_head **bh_result)

2013

{

2013

{

2014

2015

/* we want the page with the last byte in the file,

2015

/* we want the page with the last byte in the file,

2016

** not the page that will hold the next byte for appending

2016

** not the page that will hold the next byte for appending

2017

*/

2017

*/

2018

unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;

2018

unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;

2019

unsigned long pos = 0;

2019

unsigned long pos = 0;

2020

unsigned long start = 0;

2020

unsigned long start = 0;

2021

unsigned long blocksize = p_s_inode->i_sb->s_blocksize;

2021

unsigned long blocksize = p_s_inode->i_sb->s_blocksize;

2022

unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);

2022

unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);

2023

struct buffer_head *bh;

2023

struct buffer_head *bh;

2024

struct buffer_head *head;

2024

struct buffer_head *head;

2025

struct page *page;

2025

struct page *page;

2026

int error;

2026

int error;

2027

2028

/* we know that we are only called with inode->i_size > 0.

2028

/* we know that we are only called with inode->i_size > 0.

2029

** we also know that a file tail can never be as big as a block

2029

** we also know that a file tail can never be as big as a block

2030

** If i_size % blocksize == 0, our file is currently block aligned

2030

** If i_size % blocksize == 0, our file is currently block aligned

2031

** and it won't need converting or zeroing after a truncate.

2031

** and it won't need converting or zeroing after a truncate.

2032

*/

2032

*/

2033

if ((offset & (blocksize - 1)) == 0) {

2033

if ((offset & (blocksize - 1)) == 0) {

2034

return -ENOENT;

2034

return -ENOENT;

2035

}

2035

}

2036

page = grab_cache_page(p_s_inode->i_mapping, index);

2036

page = grab_cache_page(p_s_inode->i_mapping, index);

2037

error = -ENOMEM;

2037

error = -ENOMEM;

2038

if (!page) {

2038

if (!page) {

2039

goto out;

2039

goto out;

2040

}

2040

}

2041

/* start within the page of the last block in the file */

2041

/* start within the page of the last block in the file */

2042

start = (offset / blocksize) * blocksize;

2042

start = (offset / blocksize) * blocksize;

2043

2044

error = block_prepare_write(page, start, offset,

2044

error = block_prepare_write(page, start, offset,

2045

reiserfs_get_block_create_0);

2045

reiserfs_get_block_create_0);

2046

if (error)

2046

if (error)

2047

goto unlock;

2047

goto unlock;

2048

2049

head = page_buffers(page);

2049

head = page_buffers(page);

2050

bh = head;

2050

bh = head;

2051

do {

2051

do {

2052

if (pos >= start) {

2052

if (pos >= start) {

2053

break;

2053

break;

2054

}

2054

}

2055

bh = bh->b_this_page;

2055

bh = bh->b_this_page;

2056

pos += blocksize;

2056

pos += blocksize;

2057

} while (bh != head);

2057

} while (bh != head);

2058

2059

if (!buffer_uptodate(bh)) {

2059

if (!buffer_uptodate(bh)) {

2060

/* note, this should never happen, prepare_write should

2060

/* note, this should never happen, prepare_write should

2061

** be taking care of this for us. If the buffer isn't up to date,

2061

** be taking care of this for us. If the buffer isn't up to date,

2062

** I've screwed up the code to find the buffer, or the code to

2062

** I've screwed up the code to find the buffer, or the code to

2063

** call prepare_write

2063

** call prepare_write

2064

*/

2064

*/

2065

reiserfs_warning(p_s_inode->i_sb,

2065

reiserfs_warning(p_s_inode->i_sb,

2066

"clm-6000: error reading block %lu on dev %s",

2066

"clm-6000: error reading block %lu on dev %s",

2067

bh->b_blocknr,

2067

bh->b_blocknr,

2068

reiserfs_bdevname(p_s_inode->i_sb));

2068

reiserfs_bdevname(p_s_inode->i_sb));

2069

error = -EIO;

2069

error = -EIO;

2070

goto unlock;

2070

goto unlock;

2071

}

2071

}

2072

*bh_result = bh;

2072

*bh_result = bh;

2073

*page_result = page;

2073

*page_result = page;

2074

2075

out:

2075

out:

2076

return error;

2076

return error;

2077

2078

unlock:

2078

unlock:

2079

unlock_page(page);

2079

unlock_page(page);

2080

page_cache_release(page);

2080

page_cache_release(page);

2081

return error;

2081

return error;

2082

}

2082

}

2083

2084

/*

2084

/*

2085

** vfs version of truncate file. Must NOT be called with

2085

** vfs version of truncate file. Must NOT be called with

2086

** a transaction already started.

2086

** a transaction already started.

2087

**

2087

**

2088

** some code taken from block_truncate_page

2088

** some code taken from block_truncate_page

2089

*/

2089

*/

2090

int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)

2090

int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)

2091

{

2091

{

2092

struct reiserfs_transaction_handle th;

2092

struct reiserfs_transaction_handle th;

2093

/* we want the offset for the first byte after the end of the file */

2093

/* we want the offset for the first byte after the end of the file */

2094

unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);

2094

unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);

2095

unsigned blocksize = p_s_inode->i_sb->s_blocksize;

2095

unsigned blocksize = p_s_inode->i_sb->s_blocksize;

2096

unsigned length;

2096

unsigned length;

2097

struct page *page = NULL;

2097

struct page *page = NULL;

2098

int error;

2098

int error;

2099

struct buffer_head *bh = NULL;

2099

struct buffer_head *bh = NULL;

2100

2101

reiserfs_write_lock(p_s_inode->i_sb);

2101

reiserfs_write_lock(p_s_inode->i_sb);

2102

2103

if (p_s_inode->i_size > 0) {

2103

if (p_s_inode->i_size > 0) {

2104

if ((error = grab_tail_page(p_s_inode, &page, &bh))) {

2104

if ((error = grab_tail_page(p_s_inode, &page, &bh))) {

2105

// -ENOENT means we truncated past the end of the file,

2105

// -ENOENT means we truncated past the end of the file,

2106

// and get_block_create_0 could not find a block to read in,

2106

// and get_block_create_0 could not find a block to read in,

2107

// which is ok.

2107

// which is ok.

2108

if (error != -ENOENT)

2108

if (error != -ENOENT)

2109

reiserfs_warning(p_s_inode->i_sb,

2109

reiserfs_warning(p_s_inode->i_sb,

2110

"clm-6001: grab_tail_page failed %d",

2110

"clm-6001: grab_tail_page failed %d",

2111

error);

2111

error);

2112

page = NULL;

2112

page = NULL;

2113

bh = NULL;

2113

bh = NULL;

2114

}

2114

}

2115

}

2115

}

2116

2117

/* so, if page != NULL, we have a buffer head for the offset at

2117

/* so, if page != NULL, we have a buffer head for the offset at

2118

** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,

2118

** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,

2119

** then we have an unformatted node. Otherwise, we have a direct item,

2119

** then we have an unformatted node. Otherwise, we have a direct item,

2120

** and no zeroing is required on disk. We zero after the truncate,

2120

** and no zeroing is required on disk. We zero after the truncate,

2121

** because the truncate might pack the item anyway

2121

** because the truncate might pack the item anyway

2122

** (it will unmap bh if it packs).

2122

** (it will unmap bh if it packs).

2123

*/

2123

*/

2124

/* it is enough to reserve space in transaction for 2 balancings:

2124

/* it is enough to reserve space in transaction for 2 balancings:

2125

one for "save" link adding and another for the first

2125

one for "save" link adding and another for the first

2126

cut_from_item. 1 is for update_sd */

2126

cut_from_item. 1 is for update_sd */

2127

error = journal_begin(&th, p_s_inode->i_sb,

2127

error = journal_begin(&th, p_s_inode->i_sb,

2128

JOURNAL_PER_BALANCE_CNT * 2 + 1);

2128

JOURNAL_PER_BALANCE_CNT * 2 + 1);

2129

if (error)

2129

if (error)

2130

goto out;

2130

goto out;

2131

reiserfs_update_inode_transaction(p_s_inode);

2131

reiserfs_update_inode_transaction(p_s_inode);

2132

if (update_timestamps)

2132

if (update_timestamps)

2133

/* we are doing real truncate: if the system crashes before the last

2133

/* we are doing real truncate: if the system crashes before the last

2134

transaction of truncating gets committed - on reboot the file

2134

transaction of truncating gets committed - on reboot the file

2135

either appears truncated properly or not truncated at all */

2135

either appears truncated properly or not truncated at all */

2136

add_save_link(&th, p_s_inode, 1);

2136

add_save_link(&th, p_s_inode, 1);

2137

error = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);

2137

error = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);

2138

if (error)

2138

if (error)

2139

goto out;

2139

goto out;

2140

error =

2140

error =

2141

journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);

2141

journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);

2142

if (error)

2142

if (error)

2143

goto out;

2143

goto out;

2144

2145

if (update_timestamps) {

2145

if (update_timestamps) {

2146

error = remove_save_link(p_s_inode, 1 /* truncate */ );

2146

error = remove_save_link(p_s_inode, 1 /* truncate */ );

2147

if (error)

2147

if (error)

2148

goto out;

2148

goto out;

2149

}

2149

}

2150

2151

if (page) {

2151

if (page) {

2152

length = offset & (blocksize - 1);

2152

length = offset & (blocksize - 1);

2153

/* if we are not on a block boundary */

2153

/* if we are not on a block boundary */

2154

if (length) {

2154

if (length) {

2155

char *kaddr;

2155

char *kaddr;

2156

2157

length = blocksize - length;

2157

length = blocksize - length;

2158

kaddr = kmap_atomic(page, KM_USER0);

2158

kaddr = kmap_atomic(page, KM_USER0);

2159

memset(kaddr + offset, 0, length);

2159

memset(kaddr + offset, 0, length);

2160

flush_dcache_page(page);

2160

flush_dcache_page(page);

2161

kunmap_atomic(kaddr, KM_USER0);

2161

kunmap_atomic(kaddr, KM_USER0);

2162

if (buffer_mapped(bh) && bh->b_blocknr != 0) {

2162

if (buffer_mapped(bh) && bh->b_blocknr != 0) {

2163

mark_buffer_dirty(bh);

2163

mark_buffer_dirty(bh);

2164

}

2164

}

2165

}

2165

}

2166

unlock_page(page);

2166

unlock_page(page);

2167

page_cache_release(page);

2167

page_cache_release(page);

2168

}

2168

}

2169

2170

reiserfs_write_unlock(p_s_inode->i_sb);

2170

reiserfs_write_unlock(p_s_inode->i_sb);

2171

return 0;

2171

return 0;

2172

out:

2172

out:

2173

if (page) {

2173

if (page) {

2174

unlock_page(page);

2174

unlock_page(page);

2175

page_cache_release(page);

2175

page_cache_release(page);

2176

}

2176

}

2177

reiserfs_write_unlock(p_s_inode->i_sb);

2177

reiserfs_write_unlock(p_s_inode->i_sb);

2178

return error;

2178

return error;

2179

}

2179

}

2180

2181

static int map_block_for_writepage(struct inode *inode,

2181

static int map_block_for_writepage(struct inode *inode,

2182

struct buffer_head *bh_result,

2182

struct buffer_head *bh_result,

2183

unsigned long block)

2183

unsigned long block)

2184

{

2184

{

2185

struct reiserfs_transaction_handle th;

2185

struct reiserfs_transaction_handle th;

2186

int fs_gen;

2186

int fs_gen;

2187

struct item_head tmp_ih;

2187

struct item_head tmp_ih;

2188

struct item_head *ih;

2188

struct item_head *ih;

2189

struct buffer_head *bh;

2189

struct buffer_head *bh;

2190

__le32 *item;

2190

__le32 *item;

2191

struct cpu_key key;

2191

struct cpu_key key;

2192

INITIALIZE_PATH(path);

2192

INITIALIZE_PATH(path);

2193

int pos_in_item;

2193

int pos_in_item;

2194

int jbegin_count = JOURNAL_PER_BALANCE_CNT;

2194

int jbegin_count = JOURNAL_PER_BALANCE_CNT;

2195

loff_t byte_offset = (block << inode->i_sb->s_blocksize_bits) + 1;

2195

loff_t byte_offset = (block << inode->i_sb->s_blocksize_bits) + 1;

2196

int retval;

2196

int retval;

2197

int use_get_block = 0;

2197

int use_get_block = 0;

2198

int bytes_copied = 0;

2198

int bytes_copied = 0;

2199

int copy_size;

2199

int copy_size;

2200

int trans_running = 0;

2200

int trans_running = 0;

2201

2202

/* catch places below that try to log something without starting a trans */

2202

/* catch places below that try to log something without starting a trans */

2203

th.t_trans_id = 0;

2203

th.t_trans_id = 0;

2204

2205

if (!buffer_uptodate(bh_result)) {

2205

if (!buffer_uptodate(bh_result)) {

2206

return -EIO;

2206

return -EIO;

2207

}

2207

}

2208

2209

kmap(bh_result->b_page);

2209

kmap(bh_result->b_page);

2210

start_over:

2210

start_over:

2211

reiserfs_write_lock(inode->i_sb);

2211

reiserfs_write_lock(inode->i_sb);

2212

make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);

2212

make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);

2213

2214

research:

2214

research:

2215

retval = search_for_position_by_key(inode->i_sb, &key, &path);

2215

retval = search_for_position_by_key(inode->i_sb, &key, &path);

2216

if (retval != POSITION_FOUND) {

2216

if (retval != POSITION_FOUND) {

2217

use_get_block = 1;

2217

use_get_block = 1;

2218

goto out;

2218

goto out;

2219

}

2219

}

2220

2221

bh = get_last_bh(&path);

2221

bh = get_last_bh(&path);

2222

ih = get_ih(&path);

2222

ih = get_ih(&path);

2223

item = get_item(&path);

2223

item = get_item(&path);

2224

pos_in_item = path.pos_in_item;

2224

pos_in_item = path.pos_in_item;

2225

2226

/* we've found an unformatted node */

2226

/* we've found an unformatted node */

2227

if (indirect_item_found(retval, ih)) {

2227

if (indirect_item_found(retval, ih)) {

2228

if (bytes_copied > 0) {

2228

if (bytes_copied > 0) {

2229

reiserfs_warning(inode->i_sb,

2229

reiserfs_warning(inode->i_sb,

2230

"clm-6002: bytes_copied %d",

2230

"clm-6002: bytes_copied %d",

2231

bytes_copied);

2231

bytes_copied);

2232

}

2232

}

2233

if (!get_block_num(item, pos_in_item)) {

2233

if (!get_block_num(item, pos_in_item)) {

2234

/* crap, we are writing to a hole */

2234

/* crap, we are writing to a hole */

2235

use_get_block = 1;

2235

use_get_block = 1;

2236

goto out;

2236

goto out;

2237

}

2237

}

2238

set_block_dev_mapped(bh_result,

2238

set_block_dev_mapped(bh_result,

2239

get_block_num(item, pos_in_item), inode);

2239

get_block_num(item, pos_in_item), inode);

2240

} else if (is_direct_le_ih(ih)) {

2240

} else if (is_direct_le_ih(ih)) {

2241

char *p;

2241

char *p;

2242

p = page_address(bh_result->b_page);

2242

p = page_address(bh_result->b_page);

2243

p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);

2243

p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);

2244

copy_size = ih_item_len(ih) - pos_in_item;

2244

copy_size = ih_item_len(ih) - pos_in_item;

2245

2246

fs_gen = get_generation(inode->i_sb);

2246

fs_gen = get_generation(inode->i_sb);

2247

copy_item_head(&tmp_ih, ih);

2247

copy_item_head(&tmp_ih, ih);

2248

2249

if (!trans_running) {

2249

if (!trans_running) {

2250

/* vs-3050 is gone, no need to drop the path */

2250

/* vs-3050 is gone, no need to drop the path */

2251

retval = journal_begin(&th, inode->i_sb, jbegin_count);

2251

retval = journal_begin(&th, inode->i_sb, jbegin_count);

2252

if (retval)

2252

if (retval)

2253

goto out;

2253

goto out;

2254

reiserfs_update_inode_transaction(inode);

2254

reiserfs_update_inode_transaction(inode);

2255

trans_running = 1;

2255

trans_running = 1;

2256

if (fs_changed(fs_gen, inode->i_sb)

2256

if (fs_changed(fs_gen, inode->i_sb)

2257

&& item_moved(&tmp_ih, &path)) {

2257

&& item_moved(&tmp_ih, &path)) {

2258

reiserfs_restore_prepared_buffer(inode->i_sb,

2258

reiserfs_restore_prepared_buffer(inode->i_sb,

2259

bh);

2259

bh);

2260

goto research;

2260

goto research;

2261

}

2261

}

2262

}

2262

}

2263

2264

reiserfs_prepare_for_journal(inode->i_sb, bh, 1);

2264

reiserfs_prepare_for_journal(inode->i_sb, bh, 1);

2265

2266

if (fs_changed(fs_gen, inode->i_sb)

2266

if (fs_changed(fs_gen, inode->i_sb)

2267

&& item_moved(&tmp_ih, &path)) {

2267

&& item_moved(&tmp_ih, &path)) {

2268

reiserfs_restore_prepared_buffer(inode->i_sb, bh);

2268

reiserfs_restore_prepared_buffer(inode->i_sb, bh);

2269

goto research;

2269

goto research;

2270

}

2270

}

2271

2272

memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,

2272

memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,

2273

copy_size);

2273

copy_size);

2274

2275

journal_mark_dirty(&th, inode->i_sb, bh);

2275

journal_mark_dirty(&th, inode->i_sb, bh);

2276

bytes_copied += copy_size;

2276

bytes_copied += copy_size;

2277

set_block_dev_mapped(bh_result, 0, inode);

2277

set_block_dev_mapped(bh_result, 0, inode);

2278

2279

/* are there still bytes left? */

2279

/* are there still bytes left? */

2280

if (bytes_copied < bh_result->b_size &&

2280

if (bytes_copied < bh_result->b_size &&

2281

(byte_offset + bytes_copied) < inode->i_size) {

2281

(byte_offset + bytes_copied) < inode->i_size) {

2282

set_cpu_key_k_offset(&key,

2282

set_cpu_key_k_offset(&key,

2283

cpu_key_k_offset(&key) +

2283

cpu_key_k_offset(&key) +

2284

copy_size);

2284

copy_size);

2285

goto research;

2285

goto research;

2286

}

2286

}

2287

} else {

2287

} else {

2288

reiserfs_warning(inode->i_sb,

2288

reiserfs_warning(inode->i_sb,

2289

"clm-6003: bad item inode %lu, device %s",

2289

"clm-6003: bad item inode %lu, device %s",

2290

inode->i_ino, reiserfs_bdevname(inode->i_sb));

2290

inode->i_ino, reiserfs_bdevname(inode->i_sb));

2291

retval = -EIO;

2291

retval = -EIO;

2292

goto out;

2292

goto out;

2293

}

2293

}

2294

retval = 0;

2294

retval = 0;

2295

2296

out:

2296

out:

2297

pathrelse(&path);

2297

pathrelse(&path);

2298

if (trans_running) {

2298

if (trans_running) {

2299

int err = journal_end(&th, inode->i_sb, jbegin_count);

2299

int err = journal_end(&th, inode->i_sb, jbegin_count);

2300

if (err)

2300

if (err)

2301

retval = err;

2301

retval = err;

2302

trans_running = 0;

2302

trans_running = 0;

2303

}

2303

}

2304

reiserfs_write_unlock(inode->i_sb);

2304

reiserfs_write_unlock(inode->i_sb);

2305

2306

/* this is where we fill in holes in the file. */

2306

/* this is where we fill in holes in the file. */

2307

if (use_get_block) {

2307

if (use_get_block) {

2308

retval = reiserfs_get_block(inode, block, bh_result,

2308

retval = reiserfs_get_block(inode, block, bh_result,

2309

GET_BLOCK_CREATE | GET_BLOCK_NO_ISEM

2309

GET_BLOCK_CREATE | GET_BLOCK_NO_ISEM

2310

| GET_BLOCK_NO_DANGLE);

2310

| GET_BLOCK_NO_DANGLE);

2311

if (!retval) {

2311

if (!retval) {

2312

if (!buffer_mapped(bh_result)

2312

if (!buffer_mapped(bh_result)

2313

|| bh_result->b_blocknr == 0) {

2313

|| bh_result->b_blocknr == 0) {

2314

/* get_block failed to find a mapped unformatted node. */

2314

/* get_block failed to find a mapped unformatted node. */

2315

use_get_block = 0;

2315

use_get_block = 0;

2316

goto start_over;

2316

goto start_over;

2317

}

2317

}

2318

}

2318

}

2319

}

2319

}

2320

kunmap(bh_result->b_page);

2320

kunmap(bh_result->b_page);

2321

2322

if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {

2322

if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {

2323

/* we've copied data from the page into the direct item, so the

2323

/* we've copied data from the page into the direct item, so the

2324

* buffer in the page is now clean, mark it to reflect that.

2324

* buffer in the page is now clean, mark it to reflect that.

2325

*/

2325

*/

2326

lock_buffer(bh_result);

2326

lock_buffer(bh_result);

2327

clear_buffer_dirty(bh_result);

2327

clear_buffer_dirty(bh_result);

2328

unlock_buffer(bh_result);

2328

unlock_buffer(bh_result);

2329

}

2329

}

2330

return retval;

2330

return retval;

2331

}

2331

}

2332

2333

/*

2333

/*

2334

* mason@suse.com: updated in 2.5.54 to follow the same general io

2334

* mason@suse.com: updated in 2.5.54 to follow the same general io

2335

* start/recovery path as __block_write_full_page, along with special

2335

* start/recovery path as __block_write_full_page, along with special

2336

* code to handle reiserfs tails.

2336

* code to handle reiserfs tails.

2337

*/

2337

*/

2338

static int reiserfs_write_full_page(struct page *page,

2338

static int reiserfs_write_full_page(struct page *page,

2339

struct writeback_control *wbc)

2339

struct writeback_control *wbc)

2340

{

2340

{

2341

struct inode *inode = page->mapping->host;

2341

struct inode *inode = page->mapping->host;

2342

unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;

2342

unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;

2343

int error = 0;

2343

int error = 0;

2344

unsigned long block;

2344

unsigned long block;

2345

struct buffer_head *head, *bh;

2345

struct buffer_head *head, *bh;

2346

int partial = 0;

2346

int partial = 0;

2347

int nr = 0;

2347

int nr = 0;

2348

int checked = PageChecked(page);

2348

int checked = PageChecked(page);

2349

struct reiserfs_transaction_handle th;

2349

struct reiserfs_transaction_handle th;

2350

struct super_block *s = inode->i_sb;

2350

struct super_block *s = inode->i_sb;

2351

int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;

2351

int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;

2352

th.t_trans_id = 0;

2352

th.t_trans_id = 0;

2353

2354

/* The page dirty bit is cleared before writepage is called, which

2354

/* The page dirty bit is cleared before writepage is called, which

2355

* means we have to tell create_empty_buffers to make dirty buffers

2355

* means we have to tell create_empty_buffers to make dirty buffers

2356

* The page really should be up to date at this point, so tossing

2356

* The page really should be up to date at this point, so tossing

2357

* in the BH_Uptodate is just a sanity check.

2357

* in the BH_Uptodate is just a sanity check.

2358

*/

2358

*/

2359

if (!page_has_buffers(page)) {

2359

if (!page_has_buffers(page)) {

2360

create_empty_buffers(page, s->s_blocksize,

2360

create_empty_buffers(page, s->s_blocksize,

2361

(1 << BH_Dirty) | (1 << BH_Uptodate));

2361

(1 << BH_Dirty) | (1 << BH_Uptodate));

2362

}

2362

}

2363

head = page_buffers(page);

2363

head = page_buffers(page);

2364

2365

/* last page in the file, zero out any contents past the

2365

/* last page in the file, zero out any contents past the

2366

** last byte in the file

2366

** last byte in the file

2367

*/

2367

*/

2368

if (page->index >= end_index) {

2368

if (page->index >= end_index) {

2369

char *kaddr;

2369

char *kaddr;

2370

unsigned last_offset;

2370

unsigned last_offset;

2371

2372

last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);

2372

last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);

2373

/* no file contents in this page */

2373

/* no file contents in this page */

2374

if (page->index >= end_index + 1 || !last_offset) {

2374

if (page->index >= end_index + 1 || !last_offset) {

2375

unlock_page(page);

2375

unlock_page(page);

2376

return 0;

2376

return 0;

2377

}

2377

}

2378

kaddr = kmap_atomic(page, KM_USER0);

2378

kaddr = kmap_atomic(page, KM_USER0);

2379

memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);

2379

memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);

2380

flush_dcache_page(page);

2380

flush_dcache_page(page);

2381

kunmap_atomic(kaddr, KM_USER0);

2381

kunmap_atomic(kaddr, KM_USER0);

2382

}

2382

}

2383

bh = head;

2383

bh = head;

2384

block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);

2384

block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);

2385

/* first map all the buffers, logging any direct items we find */

2385

/* first map all the buffers, logging any direct items we find */

2386

do {

2386

do {

2387

if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||

2387

if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||

2388

(buffer_mapped(bh)

2388

(buffer_mapped(bh)

2389

&& bh->b_blocknr ==

2389

&& bh->b_blocknr ==

2390

0))) {

2390

0))) {

2391

/* not mapped yet, or it points to a direct item, search

2391

/* not mapped yet, or it points to a direct item, search

2392

* the btree for the mapping info, and log any direct

2392

* the btree for the mapping info, and log any direct

2393

* items found

2393

* items found

2394

*/

2394

*/

2395

if ((error = map_block_for_writepage(inode, bh, block))) {

2395

if ((error = map_block_for_writepage(inode, bh, block))) {

2396

goto fail;

2396

goto fail;

2397

}

2397

}

2398

}

2398

}

2399

bh = bh->b_this_page;

2399

bh = bh->b_this_page;

2400

block++;

2400

block++;

2401

} while (bh != head);

2401

} while (bh != head);

2402

2403

/*

2403

/*

2404

* we start the transaction after map_block_for_writepage,

2404

* we start the transaction after map_block_for_writepage,

2405

* because it can create holes in the file (an unbounded operation).

2405

* because it can create holes in the file (an unbounded operation).

2406

* starting it here, we can make a reliable estimate for how many

2406

* starting it here, we can make a reliable estimate for how many

2407

* blocks we're going to log

2407

* blocks we're going to log

2408

*/

2408

*/

2409

if (checked) {

2409

if (checked) {

2410

ClearPageChecked(page);

2410

ClearPageChecked(page);

2411

reiserfs_write_lock(s);

2411

reiserfs_write_lock(s);

2412

error = journal_begin(&th, s, bh_per_page + 1);

2412

error = journal_begin(&th, s, bh_per_page + 1);

2413

if (error) {

2413

if (error) {

2414

reiserfs_write_unlock(s);

2414

reiserfs_write_unlock(s);

2415

goto fail;

2415

goto fail;

2416

}

2416

}

2417

reiserfs_update_inode_transaction(inode);

2417

reiserfs_update_inode_transaction(inode);

2418

}

2418

}

2419

/* now go through and lock any dirty buffers on the page */

2419

/* now go through and lock any dirty buffers on the page */

2420

do {

2420

do {

2421

get_bh(bh);

2421

get_bh(bh);

2422

if (!buffer_mapped(bh))

2422

if (!buffer_mapped(bh))

2423

continue;

2423

continue;

2424

if (buffer_mapped(bh) && bh->b_blocknr == 0)

2424

if (buffer_mapped(bh) && bh->b_blocknr == 0)

2425

continue;

2425

continue;

2426

2427

if (checked) {

2427

if (checked) {

2428

reiserfs_prepare_for_journal(s, bh, 1);

2428

reiserfs_prepare_for_journal(s, bh, 1);

2429

journal_mark_dirty(&th, s, bh);

2429

journal_mark_dirty(&th, s, bh);

2430

continue;

2430

continue;

2431

}

2431

}

2432

/* from this point on, we know the buffer is mapped to a

2432

/* from this point on, we know the buffer is mapped to a

2433

* real block and not a direct item

2433

* real block and not a direct item

2434

*/

2434

*/

2435

if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {

2435

if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {

2436

lock_buffer(bh);

2436

lock_buffer(bh);

2437

} else {

2437

} else {

2438

if (test_set_buffer_locked(bh)) {

2438

if (test_set_buffer_locked(bh)) {

2439

redirty_page_for_writepage(wbc, page);

2439

redirty_page_for_writepage(wbc, page);

2440

continue;

2440

continue;

2441

}

2441

}

2442

}

2442

}

2443

if (test_clear_buffer_dirty(bh)) {

2443

if (test_clear_buffer_dirty(bh)) {

2444

mark_buffer_async_write(bh);

2444

mark_buffer_async_write(bh);

2445

} else {

2445

} else {

2446

unlock_buffer(bh);

2446

unlock_buffer(bh);

2447

}

2447

}

2448

} while ((bh = bh->b_this_page) != head);

2448

} while ((bh = bh->b_this_page) != head);

2449

2450

if (checked) {

2450

if (checked) {

2451

error = journal_end(&th, s, bh_per_page + 1);

2451

error = journal_end(&th, s, bh_per_page + 1);

2452

reiserfs_write_unlock(s);

2452

reiserfs_write_unlock(s);

2453

if (error)

2453

if (error)

2454

goto fail;

2454

goto fail;

2455

}

2455

}

2456

BUG_ON(PageWriteback(page));

2456

BUG_ON(PageWriteback(page));

2457

set_page_writeback(page);

2457

set_page_writeback(page);

2458

unlock_page(page);

2458

unlock_page(page);

2459

2460

/*

2460

/*

2461

* since any buffer might be the only dirty buffer on the page,

2461

* since any buffer might be the only dirty buffer on the page,

2462

* the first submit_bh can bring the page out of writeback.

2462

* the first submit_bh can bring the page out of writeback.

2463

* be careful with the buffers.

2463

* be careful with the buffers.

2464

*/

2464

*/

2465

do {

2465

do {

2466

struct buffer_head *next = bh->b_this_page;

2466

struct buffer_head *next = bh->b_this_page;

2467

if (buffer_async_write(bh)) {

2467

if (buffer_async_write(bh)) {

2468

submit_bh(WRITE, bh);

2468

submit_bh(WRITE, bh);

2469

nr++;

2469

nr++;

2470

}

2470

}

2471

put_bh(bh);

2471

put_bh(bh);

2472

bh = next;

2472

bh = next;

2473

} while (bh != head);

2473

} while (bh != head);

2474

2475

error = 0;

2475

error = 0;

2476

done:

2476

done:

2477

if (nr == 0) {

2477

if (nr == 0) {

2478

/*

2478

/*

2479

* if this page only had a direct item, it is very possible for

2479

* if this page only had a direct item, it is very possible for

2480

* no io to be required without there being an error. Or,

2480

* no io to be required without there being an error. Or,

2481

* someone else could have locked them and sent them down the

2481

* someone else could have locked them and sent them down the

2482

* pipe without locking the page

2482

* pipe without locking the page

2483

*/

2483

*/

2484

bh = head;

2484

bh = head;

2485

do {

2485

do {

2486

if (!buffer_uptodate(bh)) {

2486

if (!buffer_uptodate(bh)) {

2487

partial = 1;

2487

partial = 1;

2488

break;

2488

break;

2489

}

2489

}

2490

bh = bh->b_this_page;

2490

bh = bh->b_this_page;

2491

} while (bh != head);

2491

} while (bh != head);

2492

if (!partial)

2492

if (!partial)

2493

SetPageUptodate(page);

2493

SetPageUptodate(page);

2494

end_page_writeback(page);

2494

end_page_writeback(page);

2495

}

2495

}

2496

return error;

2496

return error;

2497

2498

fail:

2498

fail:

2499

/* catches various errors, we need to make sure any valid dirty blocks

2499

/* catches various errors, we need to make sure any valid dirty blocks

2500

* get to the media. The page is currently locked and not marked for

2500

* get to the media. The page is currently locked and not marked for

2501

* writeback

2501

* writeback

2502

*/

2502

*/

2503

ClearPageUptodate(page);

2503

ClearPageUptodate(page);

2504

bh = head;

2504

bh = head;

2505

do {

2505

do {

2506

get_bh(bh);

2506

get_bh(bh);

2507

if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {

2507

if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {

2508

lock_buffer(bh);

2508

lock_buffer(bh);

2509

mark_buffer_async_write(bh);

2509

mark_buffer_async_write(bh);

2510

} else {

2510

} else {

2511

/*

2511

/*

2512

* clear any dirty bits that might have come from getting

2512

* clear any dirty bits that might have come from getting

2513

* attached to a dirty page

2513

* attached to a dirty page

2514

*/

2514

*/

2515

clear_buffer_dirty(bh);

2515

clear_buffer_dirty(bh);

2516

}

2516

}

2517

bh = bh->b_this_page;

2517

bh = bh->b_this_page;

2518

} while (bh != head);

2518

} while (bh != head);

2519

SetPageError(page);

2519

SetPageError(page);

2520

BUG_ON(PageWriteback(page));

2520

BUG_ON(PageWriteback(page));

2521

set_page_writeback(page);

2521

set_page_writeback(page);

2522

unlock_page(page);

2522

unlock_page(page);

2523

do {

2523

do {

2524

struct buffer_head *next = bh->b_this_page;

2524

struct buffer_head *next = bh->b_this_page;

2525

if (buffer_async_write(bh)) {

2525

if (buffer_async_write(bh)) {

2526

clear_buffer_dirty(bh);

2526

clear_buffer_dirty(bh);

2527

submit_bh(WRITE, bh);

2527

submit_bh(WRITE, bh);

2528

nr++;

2528

nr++;

2529

}

2529

}

2530

put_bh(bh);

2530

put_bh(bh);

2531

bh = next;

2531

bh = next;

2532

} while (bh != head);

2532

} while (bh != head);

2533

goto done;

2533

goto done;

2534

}

2534

}

2535

2536

static int reiserfs_readpage(struct file *f, struct page *page)

2536

static int reiserfs_readpage(struct file *f, struct page *page)

2537

{

2537

{

2538

return block_read_full_page(page, reiserfs_get_block);

2538

return block_read_full_page(page, reiserfs_get_block);

2539

}

2539

}

2540

2541

static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)

2541

static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)

2542

{

2542

{

2543

struct inode *inode = page->mapping->host;

2543

struct inode *inode = page->mapping->host;

2544

reiserfs_wait_on_write_block(inode->i_sb);

2544

reiserfs_wait_on_write_block(inode->i_sb);

2545

return reiserfs_write_full_page(page, wbc);

2545

return reiserfs_write_full_page(page, wbc);

2546

}

2546

}

2547

2548

static int reiserfs_prepare_write(struct file *f, struct page *page,

2548

static int reiserfs_prepare_write(struct file *f, struct page *page,

2549

unsigned from, unsigned to)

2549

unsigned from, unsigned to)

2550

{

2550

{

2551

struct inode *inode = page->mapping->host;

2551

struct inode *inode = page->mapping->host;

2552

int ret;

2552

int ret;

2553

int old_ref = 0;

2553

int old_ref = 0;

2554

2555

reiserfs_wait_on_write_block(inode->i_sb);

2555

reiserfs_wait_on_write_block(inode->i_sb);

2556

fix_tail_page_for_writing(page);

2556

fix_tail_page_for_writing(page);

2557

if (reiserfs_transaction_running(inode->i_sb)) {

2557

if (reiserfs_transaction_running(inode->i_sb)) {

2558

struct reiserfs_transaction_handle *th;

2558

struct reiserfs_transaction_handle *th;

2559

th = (struct reiserfs_transaction_handle *)current->

2559

th = (struct reiserfs_transaction_handle *)current->

2560

journal_info;

2560

journal_info;

2561

BUG_ON(!th->t_refcount);

2561

BUG_ON(!th->t_refcount);

2562

BUG_ON(!th->t_trans_id);

2562

BUG_ON(!th->t_trans_id);

2563

old_ref = th->t_refcount;

2563

old_ref = th->t_refcount;

2564

th->t_refcount++;

2564

th->t_refcount++;

2565

}

2565

}

2566

2567

ret = block_prepare_write(page, from, to, reiserfs_get_block);

2567

ret = block_prepare_write(page, from, to, reiserfs_get_block);

2568

if (ret && reiserfs_transaction_running(inode->i_sb)) {

2568

if (ret && reiserfs_transaction_running(inode->i_sb)) {

2569

struct reiserfs_transaction_handle *th = current->journal_info;

2569

struct reiserfs_transaction_handle *th = current->journal_info;

2570

/* this gets a little ugly. If reiserfs_get_block returned an

2570

/* this gets a little ugly. If reiserfs_get_block returned an

2571

* error and left a transacstion running, we've got to close it,

2571

* error and left a transacstion running, we've got to close it,

2572

* and we've got to free handle if it was a persistent transaction.

2572

* and we've got to free handle if it was a persistent transaction.

2573

*

2573

*

2574

* But, if we had nested into an existing transaction, we need

2574

* But, if we had nested into an existing transaction, we need

2575

* to just drop the ref count on the handle.

2575

* to just drop the ref count on the handle.

2576

*

2576

*

2577

* If old_ref == 0, the transaction is from reiserfs_get_block,

2577

* If old_ref == 0, the transaction is from reiserfs_get_block,

2578

* and it was a persistent trans. Otherwise, it was nested above.

2578

* and it was a persistent trans. Otherwise, it was nested above.

2579

*/

2579

*/

2580

if (th->t_refcount > old_ref) {

2580

if (th->t_refcount > old_ref) {

2581

if (old_ref)

2581

if (old_ref)

2582

th->t_refcount--;

2582

th->t_refcount--;

2583

else {

2583

else {

2584

int err;

2584

int err;

2585

reiserfs_write_lock(inode->i_sb);

2585

reiserfs_write_lock(inode->i_sb);

2586

err = reiserfs_end_persistent_transaction(th);

2586

err = reiserfs_end_persistent_transaction(th);

2587

reiserfs_write_unlock(inode->i_sb);

2587

reiserfs_write_unlock(inode->i_sb);

2588

if (err)

2588

if (err)

2589

ret = err;

2589

ret = err;

2590

}

2590

}

2591

}

2591

}

2592

}

2592

}

2593

return ret;

2593

return ret;

2594

2595

}

2595

}

2596

2597

static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)

2597

static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)

2598

{

2598

{

2599

return generic_block_bmap(as, block, reiserfs_bmap);

2599

return generic_block_bmap(as, block, reiserfs_bmap);

2600

}

2600

}

2601

2602

static int reiserfs_commit_write(struct file *f, struct page *page,

2602

static int reiserfs_commit_write(struct file *f, struct page *page,

2603

unsigned from, unsigned to)

2603

unsigned from, unsigned to)

2604

{

2604

{

2605

struct inode *inode = page->mapping->host;

2605

struct inode *inode = page->mapping->host;

2606

loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;

2606

loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;

2607

int ret = 0;

2607

int ret = 0;

2608

int update_sd = 0;

2608

int update_sd = 0;

2609

struct reiserfs_transaction_handle *th = NULL;

2609

struct reiserfs_transaction_handle *th = NULL;

2610

2611

reiserfs_wait_on_write_block(inode->i_sb);

2611

reiserfs_wait_on_write_block(inode->i_sb);

2612

if (reiserfs_transaction_running(inode->i_sb)) {

2612

if (reiserfs_transaction_running(inode->i_sb)) {

2613

th = current->journal_info;

2613

th = current->journal_info;

2614

}

2614

}

2615

reiserfs_commit_page(inode, page, from, to);

2615

reiserfs_commit_page(inode, page, from, to);

2616

2617

/* generic_commit_write does this for us, but does not update the

2617

/* generic_commit_write does this for us, but does not update the

2618

** transaction tracking stuff when the size changes. So, we have

2618

** transaction tracking stuff when the size changes. So, we have

2619

** to do the i_size updates here.

2619

** to do the i_size updates here.

2620

*/

2620

*/

2621

if (pos > inode->i_size) {

2621

if (pos > inode->i_size) {

2622

struct reiserfs_transaction_handle myth;

2622

struct reiserfs_transaction_handle myth;

2623

reiserfs_write_lock(inode->i_sb);

2623

reiserfs_write_lock(inode->i_sb);

2624

/* If the file have grown beyond the border where it

2624

/* If the file have grown beyond the border where it

2625

can have a tail, unmark it as needing a tail

2625

can have a tail, unmark it as needing a tail

2626

packing */

2626

packing */

2627

if ((have_large_tails(inode->i_sb)

2627

if ((have_large_tails(inode->i_sb)

2628

&& inode->i_size > i_block_size(inode) * 4)

2628

&& inode->i_size > i_block_size(inode) * 4)

2629

|| (have_small_tails(inode->i_sb)

2629

|| (have_small_tails(inode->i_sb)

2630

&& inode->i_size > i_block_size(inode)))

2630

&& inode->i_size > i_block_size(inode)))

2631

REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;

2631

REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;

2632

2633

ret = journal_begin(&myth, inode->i_sb, 1);

2633

ret = journal_begin(&myth, inode->i_sb, 1);

2634

if (ret) {

2634

if (ret) {

2635

reiserfs_write_unlock(inode->i_sb);

2635

reiserfs_write_unlock(inode->i_sb);

2636

goto journal_error;

2636

goto journal_error;

2637

}

2637

}

2638

reiserfs_update_inode_transaction(inode);

2638

reiserfs_update_inode_transaction(inode);

2639

inode->i_size = pos;

2639

inode->i_size = pos;

2640

reiserfs_update_sd(&myth, inode);

2640

reiserfs_update_sd(&myth, inode);

2641

update_sd = 1;

2641

update_sd = 1;

2642

ret = journal_end(&myth, inode->i_sb, 1);

2642

ret = journal_end(&myth, inode->i_sb, 1);

2643

reiserfs_write_unlock(inode->i_sb);

2643

reiserfs_write_unlock(inode->i_sb);

2644

if (ret)

2644

if (ret)

2645

goto journal_error;

2645

goto journal_error;

2646

}

2646

}

2647

if (th) {

2647

if (th) {

2648

reiserfs_write_lock(inode->i_sb);

2648

reiserfs_write_lock(inode->i_sb);

2649

if (!update_sd)

2649

if (!update_sd)

2650

reiserfs_update_sd(th, inode);

2650

reiserfs_update_sd(th, inode);

2651

ret = reiserfs_end_persistent_transaction(th);

2651

ret = reiserfs_end_persistent_transaction(th);

2652

reiserfs_write_unlock(inode->i_sb);

2652

reiserfs_write_unlock(inode->i_sb);

2653

if (ret)

2653

if (ret)

2654

goto out;

2654

goto out;

2655

}

2655

}

2656

2657

/* we test for O_SYNC here so we can commit the transaction

2657

/* we test for O_SYNC here so we can commit the transaction

2658

** for any packed tails the file might have had

2658

** for any packed tails the file might have had

2659

*/

2659

*/

2660

if (f && (f->f_flags & O_SYNC)) {

2660

if (f && (f->f_flags & O_SYNC)) {

2661

reiserfs_write_lock(inode->i_sb);

2661

reiserfs_write_lock(inode->i_sb);

2662

ret = reiserfs_commit_for_inode(inode);

2662

ret = reiserfs_commit_for_inode(inode);

2663

reiserfs_write_unlock(inode->i_sb);

2663

reiserfs_write_unlock(inode->i_sb);

2664

}

2664

}

2665

out:

2665

out:

2666

return ret;

2666

return ret;

2667

2668

journal_error:

2668

journal_error:

2669

if (th) {

2669

if (th) {

2670

reiserfs_write_lock(inode->i_sb);

2670

reiserfs_write_lock(inode->i_sb);

2671

if (!update_sd)

2671

if (!update_sd)

2672

reiserfs_update_sd(th, inode);

2672

reiserfs_update_sd(th, inode);

2673

ret = reiserfs_end_persistent_transaction(th);

2673

ret = reiserfs_end_persistent_transaction(th);

2674

reiserfs_write_unlock(inode->i_sb);

2674

reiserfs_write_unlock(inode->i_sb);

2675

}

2675

}

2676

2677

return ret;

2677

return ret;

2678

}

2678

}

2679

2680

void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)

2680

void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)

2681

{

2681

{

2682

if (reiserfs_attrs(inode->i_sb)) {

2682

if (reiserfs_attrs(inode->i_sb)) {

2683

if (sd_attrs & REISERFS_SYNC_FL)

2683

if (sd_attrs & REISERFS_SYNC_FL)

2684

inode->i_flags |= S_SYNC;

2684

inode->i_flags |= S_SYNC;

2685

else

2685

else

2686

inode->i_flags &= ~S_SYNC;

2686

inode->i_flags &= ~S_SYNC;

2687

if (sd_attrs & REISERFS_IMMUTABLE_FL)

2687

if (sd_attrs & REISERFS_IMMUTABLE_FL)

2688

inode->i_flags |= S_IMMUTABLE;

2688

inode->i_flags |= S_IMMUTABLE;

2689

else

2689

else

2690

inode->i_flags &= ~S_IMMUTABLE;

2690

inode->i_flags &= ~S_IMMUTABLE;

2691

if (sd_attrs & REISERFS_APPEND_FL)

2691

if (sd_attrs & REISERFS_APPEND_FL)

2692

inode->i_flags |= S_APPEND;

2692

inode->i_flags |= S_APPEND;

2693

else

2693

else

2694

inode->i_flags &= ~S_APPEND;

2694

inode->i_flags &= ~S_APPEND;

2695

if (sd_attrs & REISERFS_NOATIME_FL)

2695

if (sd_attrs & REISERFS_NOATIME_FL)

2696

inode->i_flags |= S_NOATIME;

2696

inode->i_flags |= S_NOATIME;

2697

else

2697

else

2698

inode->i_flags &= ~S_NOATIME;

2698

inode->i_flags &= ~S_NOATIME;

2699

if (sd_attrs & REISERFS_NOTAIL_FL)

2699

if (sd_attrs & REISERFS_NOTAIL_FL)

2700

REISERFS_I(inode)->i_flags |= i_nopack_mask;

2700

REISERFS_I(inode)->i_flags |= i_nopack_mask;

2701

else

2701

else

2702

REISERFS_I(inode)->i_flags &= ~i_nopack_mask;

2702

REISERFS_I(inode)->i_flags &= ~i_nopack_mask;

2703

}

2703

}

2704

}

2704

}

2705

2706

void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)

2706

void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)

2707

{

2707

{

2708

if (reiserfs_attrs(inode->i_sb)) {

2708

if (reiserfs_attrs(inode->i_sb)) {

2709

if (inode->i_flags & S_IMMUTABLE)

2709

if (inode->i_flags & S_IMMUTABLE)

2710

*sd_attrs |= REISERFS_IMMUTABLE_FL;

2710

*sd_attrs |= REISERFS_IMMUTABLE_FL;

2711

else

2711

else

2712

*sd_attrs &= ~REISERFS_IMMUTABLE_FL;

2712

*sd_attrs &= ~REISERFS_IMMUTABLE_FL;

2713

if (inode->i_flags & S_SYNC)

2713

if (inode->i_flags & S_SYNC)

2714

*sd_attrs |= REISERFS_SYNC_FL;

2714

*sd_attrs |= REISERFS_SYNC_FL;

2715

else

2715

else

2716

*sd_attrs &= ~REISERFS_SYNC_FL;

2716

*sd_attrs &= ~REISERFS_SYNC_FL;

2717

if (inode->i_flags & S_NOATIME)

2717

if (inode->i_flags & S_NOATIME)

2718

*sd_attrs |= REISERFS_NOATIME_FL;

2718

*sd_attrs |= REISERFS_NOATIME_FL;

2719

else

2719

else

2720

*sd_attrs &= ~REISERFS_NOATIME_FL;

2720

*sd_attrs &= ~REISERFS_NOATIME_FL;

2721

if (REISERFS_I(inode)->i_flags & i_nopack_mask)

2721

if (REISERFS_I(inode)->i_flags & i_nopack_mask)

2722

*sd_attrs |= REISERFS_NOTAIL_FL;

2722

*sd_attrs |= REISERFS_NOTAIL_FL;

2723

else

2723

else

2724

*sd_attrs &= ~REISERFS_NOTAIL_FL;

2724

*sd_attrs &= ~REISERFS_NOTAIL_FL;

2725

}

2725

}

2726

}

2726

}

2727

2728

/* decide if this buffer needs to stay around for data logging or ordered

2728

/* decide if this buffer needs to stay around for data logging or ordered

2729

** write purposes

2729

** write purposes

2730

*/

2730

*/

2731

static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)

2731

static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)

2732

{

2732

{

2733

int ret = 1;

2733

int ret = 1;

2734

struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);

2734

struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);

2735

2736

spin_lock(&j->j_dirty_buffers_lock);

2736

spin_lock(&j->j_dirty_buffers_lock);

2737

if (!buffer_mapped(bh)) {

2737

if (!buffer_mapped(bh)) {

2738

goto free_jh;

2738

goto free_jh;

2739

}

2739

}

2740

/* the page is locked, and the only places that log a data buffer

2740

/* the page is locked, and the only places that log a data buffer

2741

* also lock the page.

2741

* also lock the page.

2742

*/

2742

*/

2743

if (reiserfs_file_data_log(inode)) {

2743

if (reiserfs_file_data_log(inode)) {

2744

/*

2744

/*

2745

* very conservative, leave the buffer pinned if

2745

* very conservative, leave the buffer pinned if

2746

* anyone might need it.

2746

* anyone might need it.

2747

*/

2747

*/

2748

if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {

2748

if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {

2749

ret = 0;

2749

ret = 0;

2750

}

2750

}

2751

} else if (buffer_dirty(bh) || buffer_locked(bh)) {

2751

} else if (buffer_dirty(bh) || buffer_locked(bh)) {

2752

struct reiserfs_journal_list *jl;

2752

struct reiserfs_journal_list *jl;

2753

struct reiserfs_jh *jh = bh->b_private;

2753

struct reiserfs_jh *jh = bh->b_private;

2754

2755

/* why is this safe?

2755

/* why is this safe?

2756

* reiserfs_setattr updates i_size in the on disk

2756

* reiserfs_setattr updates i_size in the on disk

2757

* stat data before allowing vmtruncate to be called.

2757

* stat data before allowing vmtruncate to be called.

2758

*

2758

*

2759

* If buffer was put onto the ordered list for this

2759

* If buffer was put onto the ordered list for this

2760

* transaction, we know for sure either this transaction

2760

* transaction, we know for sure either this transaction

2761

* or an older one already has updated i_size on disk,

2761

* or an older one already has updated i_size on disk,

2762

* and this ordered data won't be referenced in the file

2762

* and this ordered data won't be referenced in the file

2763

* if we crash.

2763

* if we crash.

2764

*

2764

*

2765

* if the buffer was put onto the ordered list for an older

2765

* if the buffer was put onto the ordered list for an older

2766

* transaction, we need to leave it around

2766

* transaction, we need to leave it around

2767

*/

2767

*/

2768

if (jh && (jl = jh->jl)

2768

if (jh && (jl = jh->jl)

2769

&& jl != SB_JOURNAL(inode->i_sb)->j_current_jl)

2769

&& jl != SB_JOURNAL(inode->i_sb)->j_current_jl)

2770

ret = 0;

2770

ret = 0;

2771

}

2771

}

2772

free_jh:

2772

free_jh:

2773

if (ret && bh->b_private) {

2773

if (ret && bh->b_private) {

2774

reiserfs_free_jh(bh);

2774

reiserfs_free_jh(bh);

2775

}

2775

}

2776

spin_unlock(&j->j_dirty_buffers_lock);

2776

spin_unlock(&j->j_dirty_buffers_lock);

2777

return ret;

2777

return ret;

2778

}

2778

}

2779

2780

/* clm -- taken from fs/buffer.c:block_invalidate_page */

2780

/* clm -- taken from fs/buffer.c:block_invalidate_page */

2781

static int reiserfs_invalidatepage(struct page *page, unsigned long offset)

2781

static int reiserfs_invalidatepage(struct page *page, unsigned long offset)

2782

{

2782

{

2783

struct buffer_head *head, *bh, *next;

2783

struct buffer_head *head, *bh, *next;

2784

struct inode *inode = page->mapping->host;

2784

struct inode *inode = page->mapping->host;

2785

unsigned int curr_off = 0;

2785

unsigned int curr_off = 0;

2786

int ret = 1;

2786

int ret = 1;

2787

2788

BUG_ON(!PageLocked(page));

2788

BUG_ON(!PageLocked(page));

2789

2790

if (offset == 0)

2790

if (offset == 0)

2791

ClearPageChecked(page);

2791

ClearPageChecked(page);

2792

2793

if (!page_has_buffers(page))

2793

if (!page_has_buffers(page))

2794

goto out;

2794

goto out;

2795

2796

head = page_buffers(page);

2796

head = page_buffers(page);

2797

bh = head;

2797

bh = head;

2798

do {

2798

do {

2799

unsigned int next_off = curr_off + bh->b_size;

2799

unsigned int next_off = curr_off + bh->b_size;

2800

next = bh->b_this_page;

2800

next = bh->b_this_page;

2801

2802

/*

2802

/*

2803

* is this block fully invalidated?

2803

* is this block fully invalidated?

2804

*/

2804

*/

2805

if (offset <= curr_off) {

2805

if (offset <= curr_off) {

2806

if (invalidatepage_can_drop(inode, bh))

2806

if (invalidatepage_can_drop(inode, bh))

2807

reiserfs_unmap_buffer(bh);

2807

reiserfs_unmap_buffer(bh);

2808

else

2808

else

2809

ret = 0;

2809

ret = 0;

2810

}

2810

}

2811

curr_off = next_off;

2811

curr_off = next_off;

2812

bh = next;

2812

bh = next;

2813

} while (bh != head);

2813

} while (bh != head);

2814

2815

/*

2815

/*

2816

* We release buffers only if the entire page is being invalidated.

2816

* We release buffers only if the entire page is being invalidated.

2817

* The get_block cached value has been unconditionally invalidated,

2817

* The get_block cached value has been unconditionally invalidated,

2818

* so real IO is not possible anymore.

2818

* so real IO is not possible anymore.

2819

*/

2819

*/

2820

if (!offset && ret)

2820

if (!offset && ret)

2821

ret = try_to_release_page(page, 0);

2821

ret = try_to_release_page(page, 0);

2822

out:

2822

out:

2823

return ret;

2823

return ret;

2824

}

2824

}

2825

2826

static int reiserfs_set_page_dirty(struct page *page)

2826

static int reiserfs_set_page_dirty(struct page *page)

2827

{

2827

{

2828

struct inode *inode = page->mapping->host;

2828

struct inode *inode = page->mapping->host;

2829

if (reiserfs_file_data_log(inode)) {

2829

if (reiserfs_file_data_log(inode)) {

2830

SetPageChecked(page);

2830

SetPageChecked(page);

2831

return __set_page_dirty_nobuffers(page);

2831

return __set_page_dirty_nobuffers(page);

2832

}

2832

}

2833

return __set_page_dirty_buffers(page);

2833

return __set_page_dirty_buffers(page);

2834

}

2834

}

2835

2836

/*

2836

/*

2837

* Returns 1 if the page's buffers were dropped. The page is locked.

2837

* Returns 1 if the page's buffers were dropped. The page is locked.

2838

*

2838

*

2839

* Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads

2839

* Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads

2840

* in the buffers at page_buffers(page).

2840

* in the buffers at page_buffers(page).

2841

*

2841

*

2842

* even in -o notail mode, we can't be sure an old mount without -o notail

2842

* even in -o notail mode, we can't be sure an old mount without -o notail

2843

* didn't create files with tails.

2843

* didn't create files with tails.

2844

*/

2844

*/

2845

static int reiserfs_releasepage(struct page *page, int unused_gfp_flags)

2845

static int reiserfs_releasepage(struct page *page, int unused_gfp_flags)

2846

{

2846

{

2847

struct inode *inode = page->mapping->host;

2847

struct inode *inode = page->mapping->host;

2848

struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);

2848

struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);

2849

struct buffer_head *head;

2849

struct buffer_head *head;

2850

struct buffer_head *bh;

2850

struct buffer_head *bh;

2851

int ret = 1;

2851

int ret = 1;

2852

2853

WARN_ON(PageChecked(page));

2853

WARN_ON(PageChecked(page));

2854

spin_lock(&j->j_dirty_buffers_lock);

2854

spin_lock(&j->j_dirty_buffers_lock);

2855

head = page_buffers(page);

2855

head = page_buffers(page);

2856

bh = head;

2856

bh = head;

2857

do {

2857

do {

2858

if (bh->b_private) {

2858

if (bh->b_private) {

2859

if (!buffer_dirty(bh) && !buffer_locked(bh)) {

2859

if (!buffer_dirty(bh) && !buffer_locked(bh)) {

2860

reiserfs_free_jh(bh);

2860

reiserfs_free_jh(bh);

2861

} else {

2861

} else {

2862

ret = 0;

2862

ret = 0;

2863

break;

2863

break;

2864

}

2864

}

2865

}

2865

}

2866

bh = bh->b_this_page;

2866

bh = bh->b_this_page;

2867

} while (bh != head);

2867

} while (bh != head);

2868

if (ret)

2868

if (ret)

2869

ret = try_to_free_buffers(page);

2869

ret = try_to_free_buffers(page);

2870

spin_unlock(&j->j_dirty_buffers_lock);

2870

spin_unlock(&j->j_dirty_buffers_lock);

2871

return ret;

2871

return ret;

2872

}

2872

}

2873

2874

/* We thank Mingming Cao for helping us understand in great detail what

2874

/* We thank Mingming Cao for helping us understand in great detail what

2875

to do in this section of the code. */

2875

to do in this section of the code. */

2876

static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,

2876

static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,

2877

const struct iovec *iov, loff_t offset,

2877

const struct iovec *iov, loff_t offset,

2878

unsigned long nr_segs)

2878

unsigned long nr_segs)

2879

{

2879

{

2880

struct file *file = iocb->ki_filp;

2880

struct file *file = iocb->ki_filp;

2881

struct inode *inode = file->f_mapping->host;

2881

struct inode *inode = file->f_mapping->host;

2882

2883

return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,

2883

return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,

2884

offset, nr_segs,

2884

offset, nr_segs,

2885

reiserfs_get_blocks_direct_io, NULL);

2885

reiserfs_get_blocks_direct_io, NULL);

2886

}

2886

}

2887

2888

int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)

2888

int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)

2889

{

2889

{

2890

struct inode *inode = dentry->d_inode;

2890

struct inode *inode = dentry->d_inode;

2891

int error;

2891

int error;

2892

unsigned int ia_valid = attr->ia_valid;

2892

unsigned int ia_valid = attr->ia_valid;

2893

reiserfs_write_lock(inode->i_sb);

2893

reiserfs_write_lock(inode->i_sb);

2894

if (attr->ia_valid & ATTR_SIZE) {

2894

if (attr->ia_valid & ATTR_SIZE) {

2895

/* version 2 items will be caught by the s_maxbytes check

2895

/* version 2 items will be caught by the s_maxbytes check

2896

** done for us in vmtruncate

2896

** done for us in vmtruncate

2897

*/

2897

*/

2898

if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&

2898

if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&

2899

attr->ia_size > MAX_NON_LFS) {

2899

attr->ia_size > MAX_NON_LFS) {

2900

error = -EFBIG;

2900

error = -EFBIG;

2901

goto out;

2901

goto out;

2902

}

2902

}

2903

/* fill in hole pointers in the expanding truncate case. */

2903

/* fill in hole pointers in the expanding truncate case. */

2904

if (attr->ia_size > inode->i_size) {

2904

if (attr->ia_size > inode->i_size) {

2905

error = generic_cont_expand(inode, attr->ia_size);

2905

error = generic_cont_expand(inode, attr->ia_size);

2906

if (REISERFS_I(inode)->i_prealloc_count > 0) {

2906

if (REISERFS_I(inode)->i_prealloc_count > 0) {

2907

int err;

2907

int err;

2908

struct reiserfs_transaction_handle th;

2908

struct reiserfs_transaction_handle th;

2909

/* we're changing at most 2 bitmaps, inode + super */

2909

/* we're changing at most 2 bitmaps, inode + super */

2910

err = journal_begin(&th, inode->i_sb, 4);

2910

err = journal_begin(&th, inode->i_sb, 4);

2911

if (!err) {

2911

if (!err) {

2912

reiserfs_discard_prealloc(&th, inode);

2912

reiserfs_discard_prealloc(&th, inode);

2913

err = journal_end(&th, inode->i_sb, 4);

2913

err = journal_end(&th, inode->i_sb, 4);

2914

}

2914

}

2915

if (err)

2915

if (err)

2916

error = err;

2916

error = err;

2917

}

2917

}

2918

if (error)

2918

if (error)

2919

goto out;

2919

goto out;

2920

}

2920

}

2921

}

2921

}

2922

2923

if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||

2923

if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||

2924

((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&

2924

((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&

2925

(get_inode_sd_version(inode) == STAT_DATA_V1)) {

2925

(get_inode_sd_version(inode) == STAT_DATA_V1)) {

2926

/* stat data of format v3.5 has 16 bit uid and gid */

2926

/* stat data of format v3.5 has 16 bit uid and gid */

2927

error = -EINVAL;

2927

error = -EINVAL;

2928

goto out;

2928

goto out;

2929

}

2929

}

2930

2931

error = inode_change_ok(inode, attr);

2931

error = inode_change_ok(inode, attr);

2932

if (!error) {

2932

if (!error) {

2933

if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||

2933

if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||

2934

(ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {

2934

(ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {

2935

error = reiserfs_chown_xattrs(inode, attr);

2935

error = reiserfs_chown_xattrs(inode, attr);

2936

2937

if (!error) {

2937

if (!error) {

2938

struct reiserfs_transaction_handle th;

2938

struct reiserfs_transaction_handle th;

2939

int jbegin_count =

2939

int jbegin_count =

2940

2 *

2940

2 *

2941

(REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +

2941

(REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +

2942

REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +

2942

REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +

2943

2;

2943

2;

2944

2945

/* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */

2945

/* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */

2946

error =

2946

error =

2947

journal_begin(&th, inode->i_sb,

2947

journal_begin(&th, inode->i_sb,

2948

jbegin_count);

2948

jbegin_count);

2949

if (error)

2949

if (error)

2950

goto out;

2950

goto out;

2951

error =

2951

error =

2952

DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;

2952

DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;

2953

if (error) {

2953

if (error) {

2954

journal_end(&th, inode->i_sb,

2954

journal_end(&th, inode->i_sb,

2955

jbegin_count);

2955

jbegin_count);

2956

goto out;

2956

goto out;

2957

}

2957

}

2958

/* Update corresponding info in inode so that everything is in

2958

/* Update corresponding info in inode so that everything is in

2959

* one transaction */

2959

* one transaction */

2960

if (attr->ia_valid & ATTR_UID)

2960

if (attr->ia_valid & ATTR_UID)

2961

inode->i_uid = attr->ia_uid;

2961

inode->i_uid = attr->ia_uid;

2962

if (attr->ia_valid & ATTR_GID)

2962

if (attr->ia_valid & ATTR_GID)

2963

inode->i_gid = attr->ia_gid;

2963

inode->i_gid = attr->ia_gid;

2964

mark_inode_dirty(inode);

2964

mark_inode_dirty(inode);

2965

error =

2965

error =

2966

journal_end(&th, inode->i_sb, jbegin_count);

2966

journal_end(&th, inode->i_sb, jbegin_count);

2967

}

2967

}

2968

}

2968

}

2969

if (!error)

2969

if (!error)

2970

error = inode_setattr(inode, attr);

2970

error = inode_setattr(inode, attr);

2971

}

2971

}

2972

2973

if (!error && reiserfs_posixacl(inode->i_sb)) {

2973

if (!error && reiserfs_posixacl(inode->i_sb)) {

2974

if (attr->ia_valid & ATTR_MODE)

2974

if (attr->ia_valid & ATTR_MODE)

2975

error = reiserfs_acl_chmod(inode);

2975

error = reiserfs_acl_chmod(inode);

2976

}

2976

}

2977

2978

out:

2978

out:

2979

reiserfs_write_unlock(inode->i_sb);

2979

reiserfs_write_unlock(inode->i_sb);

2980

return error;

2980

return error;

2981

}

2981

}

2982

2983

struct address_space_operations reiserfs_address_space_operations = {

2983

struct address_space_operations reiserfs_address_space_operations = {

2984

.writepage = reiserfs_writepage,

2984

.writepage = reiserfs_writepage,

2985

.readpage = reiserfs_readpage,

2985

.readpage = reiserfs_readpage,

2986

.readpages = reiserfs_readpages,

2986

.readpages = reiserfs_readpages,

2987

.releasepage = reiserfs_releasepage,

2987

.releasepage = reiserfs_releasepage,

2988

.invalidatepage = reiserfs_invalidatepage,

2988

.invalidatepage = reiserfs_invalidatepage,

2989

.sync_page = block_sync_page,

2989

.sync_page = block_sync_page,

2990

.prepare_write = reiserfs_prepare_write,

2990

.prepare_write = reiserfs_prepare_write,

2991

.commit_write = reiserfs_commit_write,

2991

.commit_write = reiserfs_commit_write,

2992

.bmap = reiserfs_aop_bmap,

2992

.bmap = reiserfs_aop_bmap,

2993

.direct_IO = reiserfs_direct_IO,

2993

.direct_IO = reiserfs_direct_IO,

2994

.set_page_dirty = reiserfs_set_page_dirty,

2994

.set_page_dirty = reiserfs_set_page_dirty,

2995

};

2995

};

2996

GITLAB

[PATCH] reiserfs+acl+quota deadlock fix