Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ryusuke/nilfs2
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ryusuke/nilfs2:
nilfs2: fix possible mismatch of sufile counters on recovery
nilfs2: segment usage file cleanups
nilfs2: fix wrong accounting and duplicate brelse in nilfs_sufile_set_error
nilfs2: simplify handling of active state of segments fix
nilfs2: remove module version
nilfs2: fix lockdep recursive locking warning on meta data files
nilfs2: fix lockdep recursive locking warning on bmap
nilfs2: return f_fsid for statfs2
+198
-214
+5
fs/nilfs2/bmap.c
+5
fs/nilfs2/bmap.c
···
688
688
.bpop_translate = NULL,
689
689
};
690
690
691
+
static struct lock_class_key nilfs_bmap_dat_lock_key;
692
+
691
693
/**
692
694
* nilfs_bmap_read - read a bmap from an inode
693
695
* @bmap: bmap
···
717
715
bmap->b_pops = &nilfs_bmap_ptr_ops_p;
718
716
bmap->b_last_allocated_key = 0; /* XXX: use macro */
719
717
bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT;
718
+
lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);
720
719
break;
721
720
case NILFS_CPFILE_INO:
722
721
case NILFS_SUFILE_INO:
···
775
772
{
776
773
memcpy(gcbmap, bmap, sizeof(union nilfs_bmap_union));
777
774
init_rwsem(&gcbmap->b_sem);
775
+
lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);
778
776
gcbmap->b_inode = &NILFS_BMAP_I(gcbmap)->vfs_inode;
779
777
}
780
778
···
783
779
{
784
780
memcpy(bmap, gcbmap, sizeof(union nilfs_bmap_union));
785
781
init_rwsem(&bmap->b_sem);
782
+
lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);
786
783
bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode;
787
784
}
-5
fs/nilfs2/nilfs.h
-5
fs/nilfs2/nilfs.h
+4
-16
fs/nilfs2/recovery.c
+4
-16
fs/nilfs2/recovery.c
···
413
413
struct nilfs_segment_entry *ent, *n;
414
414
struct inode *sufile = nilfs->ns_sufile;
415
415
__u64 segnum[4];
416
-
time_t mtime;
417
416
int err;
418
417
int i;
419
418
···
441
442
* Collecting segments written after the latest super root.
442
443
* These are marked dirty to avoid being reallocated in the next write.
443
444
*/
444
-
mtime = get_seconds();
445
445
list_for_each_entry_safe(ent, n, head, list) {
446
-
if (ent->segnum == segnum[0]) {
447
-
list_del(&ent->list);
448
-
nilfs_free_segment_entry(ent);
449
-
continue;
450
-
}
451
-
err = nilfs_open_segment_entry(ent, sufile);
452
-
if (unlikely(err))
453
-
goto failed;
454
-
if (!nilfs_segment_usage_dirty(ent->raw_su)) {
455
-
/* make the segment garbage */
456
-
ent->raw_su->su_nblocks = cpu_to_le32(0);
457
-
ent->raw_su->su_lastmod = cpu_to_le32(mtime);
458
-
nilfs_segment_usage_set_dirty(ent->raw_su);
446
+
if (ent->segnum != segnum[0]) {
447
+
err = nilfs_sufile_scrap(sufile, ent->segnum);
448
+
if (unlikely(err))
449
+
goto failed;
459
450
}
460
451
list_del(&ent->list);
461
-
nilfs_close_segment_entry(ent, sufile);
462
452
nilfs_free_segment_entry(ent);
463
453
}
464
454
+105
-187
fs/nilfs2/sufile.c
+105
-187
fs/nilfs2/sufile.c
···
93
93
create, NULL, bhp);
94
94
}
95
95
96
+
static void nilfs_sufile_mod_counter(struct buffer_head *header_bh,
97
+
u64 ncleanadd, u64 ndirtyadd)
98
+
{
99
+
struct nilfs_sufile_header *header;
100
+
void *kaddr;
101
+
102
+
kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
103
+
header = kaddr + bh_offset(header_bh);
104
+
le64_add_cpu(&header->sh_ncleansegs, ncleanadd);
105
+
le64_add_cpu(&header->sh_ndirtysegs, ndirtyadd);
106
+
kunmap_atomic(kaddr, KM_USER0);
107
+
108
+
nilfs_mdt_mark_buffer_dirty(header_bh);
109
+
}
110
+
111
+
int nilfs_sufile_update(struct inode *sufile, __u64 segnum, int create,
112
+
void (*dofunc)(struct inode *, __u64,
113
+
struct buffer_head *,
114
+
struct buffer_head *))
115
+
{
116
+
struct buffer_head *header_bh, *bh;
117
+
int ret;
118
+
119
+
if (unlikely(segnum >= nilfs_sufile_get_nsegments(sufile))) {
120
+
printk(KERN_WARNING "%s: invalid segment number: %llu\n",
121
+
__func__, (unsigned long long)segnum);
122
+
return -EINVAL;
123
+
}
124
+
down_write(&NILFS_MDT(sufile)->mi_sem);
125
+
126
+
ret = nilfs_sufile_get_header_block(sufile, &header_bh);
127
+
if (ret < 0)
128
+
goto out_sem;
129
+
130
+
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, create, &bh);
131
+
if (!ret) {
132
+
dofunc(sufile, segnum, header_bh, bh);
133
+
brelse(bh);
134
+
}
135
+
brelse(header_bh);
136
+
137
+
out_sem:
138
+
up_write(&NILFS_MDT(sufile)->mi_sem);
139
+
return ret;
140
+
}
141
+
96
142
/**
97
143
* nilfs_sufile_alloc - allocate a segment
98
144
* @sufile: inode of segment usage file
···
159
113
int nilfs_sufile_alloc(struct inode *sufile, __u64 *segnump)
160
114
{
161
115
struct buffer_head *header_bh, *su_bh;
162
-
struct the_nilfs *nilfs;
163
116
struct nilfs_sufile_header *header;
164
117
struct nilfs_segment_usage *su;
165
118
size_t susz = NILFS_MDT(sufile)->mi_entry_size;
···
168
123
int ret, i, j;
169
124
170
125
down_write(&NILFS_MDT(sufile)->mi_sem);
171
-
172
-
nilfs = NILFS_MDT(sufile)->mi_nilfs;
173
126
174
127
ret = nilfs_sufile_get_header_block(sufile, &header_bh);
175
128
if (ret < 0)
···
235
192
return ret;
236
193
}
237
194
238
-
/**
239
-
* nilfs_sufile_cancel_free -
240
-
* @sufile: inode of segment usage file
241
-
* @segnum: segment number
242
-
*
243
-
* Description:
244
-
*
245
-
* Return Value: On success, 0 is returned. On error, one of the following
246
-
* negative error codes is returned.
247
-
*
248
-
* %-EIO - I/O error.
249
-
*
250
-
* %-ENOMEM - Insufficient amount of memory available.
251
-
*/
252
-
int nilfs_sufile_cancel_free(struct inode *sufile, __u64 segnum)
195
+
void nilfs_sufile_do_cancel_free(struct inode *sufile, __u64 segnum,
196
+
struct buffer_head *header_bh,
197
+
struct buffer_head *su_bh)
253
198
{
254
-
struct buffer_head *header_bh, *su_bh;
255
-
struct the_nilfs *nilfs;
256
-
struct nilfs_sufile_header *header;
257
199
struct nilfs_segment_usage *su;
258
200
void *kaddr;
259
-
int ret;
260
-
261
-
down_write(&NILFS_MDT(sufile)->mi_sem);
262
-
263
-
nilfs = NILFS_MDT(sufile)->mi_nilfs;
264
-
265
-
ret = nilfs_sufile_get_header_block(sufile, &header_bh);
266
-
if (ret < 0)
267
-
goto out_sem;
268
-
269
-
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &su_bh);
270
-
if (ret < 0)
271
-
goto out_header;
272
201
273
202
kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
274
-
su = nilfs_sufile_block_get_segment_usage(
275
-
sufile, segnum, su_bh, kaddr);
203
+
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
276
204
if (unlikely(!nilfs_segment_usage_clean(su))) {
277
205
printk(KERN_WARNING "%s: segment %llu must be clean\n",
278
206
__func__, (unsigned long long)segnum);
279
207
kunmap_atomic(kaddr, KM_USER0);
280
-
goto out_su_bh;
208
+
return;
281
209
}
282
210
nilfs_segment_usage_set_dirty(su);
283
211
kunmap_atomic(kaddr, KM_USER0);
284
212
285
-
kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
286
-
header = nilfs_sufile_block_get_header(sufile, header_bh, kaddr);
287
-
le64_add_cpu(&header->sh_ncleansegs, -1);
288
-
le64_add_cpu(&header->sh_ndirtysegs, 1);
289
-
kunmap_atomic(kaddr, KM_USER0);
290
-
291
-
nilfs_mdt_mark_buffer_dirty(header_bh);
213
+
nilfs_sufile_mod_counter(header_bh, -1, 1);
292
214
nilfs_mdt_mark_buffer_dirty(su_bh);
293
215
nilfs_mdt_mark_dirty(sufile);
294
-
295
-
out_su_bh:
296
-
brelse(su_bh);
297
-
out_header:
298
-
brelse(header_bh);
299
-
out_sem:
300
-
up_write(&NILFS_MDT(sufile)->mi_sem);
301
-
return ret;
302
216
}
303
217
304
-
/**
305
-
* nilfs_sufile_freev - free segments
306
-
* @sufile: inode of segment usage file
307
-
* @segnum: array of segment numbers
308
-
* @nsegs: number of segments
309
-
*
310
-
* Description: nilfs_sufile_freev() frees segments specified by @segnum and
311
-
* @nsegs, which must have been returned by a previous call to
312
-
* nilfs_sufile_alloc().
313
-
*
314
-
* Return Value: On success, 0 is returned. On error, one of the following
315
-
* negative error codes is returned.
316
-
*
317
-
* %-EIO - I/O error.
318
-
*
319
-
* %-ENOMEM - Insufficient amount of memory available.
320
-
*/
321
-
#define NILFS_SUFILE_FREEV_PREALLOC 16
322
-
int nilfs_sufile_freev(struct inode *sufile, __u64 *segnum, size_t nsegs)
218
+
void nilfs_sufile_do_scrap(struct inode *sufile, __u64 segnum,
219
+
struct buffer_head *header_bh,
220
+
struct buffer_head *su_bh)
323
221
{
324
-
struct buffer_head *header_bh, **su_bh,
325
-
*su_bh_prealloc[NILFS_SUFILE_FREEV_PREALLOC];
326
-
struct the_nilfs *nilfs;
327
-
struct nilfs_sufile_header *header;
328
222
struct nilfs_segment_usage *su;
329
223
void *kaddr;
330
-
int ret, i;
224
+
int clean, dirty;
331
225
332
-
down_write(&NILFS_MDT(sufile)->mi_sem);
333
-
334
-
nilfs = NILFS_MDT(sufile)->mi_nilfs;
335
-
336
-
/* prepare resources */
337
-
if (nsegs <= NILFS_SUFILE_FREEV_PREALLOC)
338
-
su_bh = su_bh_prealloc;
339
-
else {
340
-
su_bh = kmalloc(sizeof(*su_bh) * nsegs, GFP_NOFS);
341
-
if (su_bh == NULL) {
342
-
ret = -ENOMEM;
343
-
goto out_sem;
344
-
}
345
-
}
346
-
347
-
ret = nilfs_sufile_get_header_block(sufile, &header_bh);
348
-
if (ret < 0)
349
-
goto out_su_bh;
350
-
for (i = 0; i < nsegs; i++) {
351
-
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum[i],
352
-
0, &su_bh[i]);
353
-
if (ret < 0)
354
-
goto out_bh;
355
-
}
356
-
357
-
/* free segments */
358
-
for (i = 0; i < nsegs; i++) {
359
-
kaddr = kmap_atomic(su_bh[i]->b_page, KM_USER0);
360
-
su = nilfs_sufile_block_get_segment_usage(
361
-
sufile, segnum[i], su_bh[i], kaddr);
362
-
WARN_ON(nilfs_segment_usage_error(su));
363
-
nilfs_segment_usage_set_clean(su);
226
+
kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
227
+
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
228
+
if (su->su_flags == cpu_to_le32(1UL << NILFS_SEGMENT_USAGE_DIRTY) &&
229
+
su->su_nblocks == cpu_to_le32(0)) {
364
230
kunmap_atomic(kaddr, KM_USER0);
365
-
nilfs_mdt_mark_buffer_dirty(su_bh[i]);
231
+
return;
366
232
}
367
-
kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
368
-
header = nilfs_sufile_block_get_header(sufile, header_bh, kaddr);
369
-
le64_add_cpu(&header->sh_ncleansegs, nsegs);
370
-
le64_add_cpu(&header->sh_ndirtysegs, -(u64)nsegs);
233
+
clean = nilfs_segment_usage_clean(su);
234
+
dirty = nilfs_segment_usage_dirty(su);
235
+
236
+
/* make the segment garbage */
237
+
su->su_lastmod = cpu_to_le64(0);
238
+
su->su_nblocks = cpu_to_le32(0);
239
+
su->su_flags = cpu_to_le32(1UL << NILFS_SEGMENT_USAGE_DIRTY);
371
240
kunmap_atomic(kaddr, KM_USER0);
372
-
nilfs_mdt_mark_buffer_dirty(header_bh);
241
+
242
+
nilfs_sufile_mod_counter(header_bh, clean ? (u64)-1 : 0, dirty ? 0 : 1);
243
+
nilfs_mdt_mark_buffer_dirty(su_bh);
373
244
nilfs_mdt_mark_dirty(sufile);
374
-
375
-
out_bh:
376
-
for (i--; i >= 0; i--)
377
-
brelse(su_bh[i]);
378
-
brelse(header_bh);
379
-
380
-
out_su_bh:
381
-
if (su_bh != su_bh_prealloc)
382
-
kfree(su_bh);
383
-
384
-
out_sem:
385
-
up_write(&NILFS_MDT(sufile)->mi_sem);
386
-
return ret;
387
245
}
388
246
389
-
/**
390
-
* nilfs_sufile_free -
391
-
* @sufile:
392
-
* @segnum:
393
-
*/
394
-
int nilfs_sufile_free(struct inode *sufile, __u64 segnum)
247
+
void nilfs_sufile_do_free(struct inode *sufile, __u64 segnum,
248
+
struct buffer_head *header_bh,
249
+
struct buffer_head *su_bh)
395
250
{
396
-
return nilfs_sufile_freev(sufile, &segnum, 1);
251
+
struct nilfs_segment_usage *su;
252
+
void *kaddr;
253
+
int sudirty;
254
+
255
+
kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
256
+
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
257
+
if (nilfs_segment_usage_clean(su)) {
258
+
printk(KERN_WARNING "%s: segment %llu is already clean\n",
259
+
__func__, (unsigned long long)segnum);
260
+
kunmap_atomic(kaddr, KM_USER0);
261
+
return;
262
+
}
263
+
WARN_ON(nilfs_segment_usage_error(su));
264
+
WARN_ON(!nilfs_segment_usage_dirty(su));
265
+
266
+
sudirty = nilfs_segment_usage_dirty(su);
267
+
nilfs_segment_usage_set_clean(su);
268
+
kunmap_atomic(kaddr, KM_USER0);
269
+
nilfs_mdt_mark_buffer_dirty(su_bh);
270
+
271
+
nilfs_sufile_mod_counter(header_bh, 1, sudirty ? (u64)-1 : 0);
272
+
nilfs_mdt_mark_dirty(sufile);
397
273
}
398
274
399
275
/**
···
462
500
return ret;
463
501
}
464
502
465
-
/**
466
-
* nilfs_sufile_set_error - mark a segment as erroneous
467
-
* @sufile: inode of segment usage file
468
-
* @segnum: segment number
469
-
*
470
-
* Description: nilfs_sufile_set_error() marks the segment specified by
471
-
* @segnum as erroneous. The error segment will never be used again.
472
-
*
473
-
* Return Value: On success, 0 is returned. On error, one of the following
474
-
* negative error codes is returned.
475
-
*
476
-
* %-EIO - I/O error.
477
-
*
478
-
* %-ENOMEM - Insufficient amount of memory available.
479
-
*
480
-
* %-EINVAL - Invalid segment usage number.
481
-
*/
482
-
int nilfs_sufile_set_error(struct inode *sufile, __u64 segnum)
503
+
void nilfs_sufile_do_set_error(struct inode *sufile, __u64 segnum,
504
+
struct buffer_head *header_bh,
505
+
struct buffer_head *su_bh)
483
506
{
484
-
struct buffer_head *header_bh, *su_bh;
485
507
struct nilfs_segment_usage *su;
486
-
struct nilfs_sufile_header *header;
487
508
void *kaddr;
488
-
int ret;
489
-
490
-
if (unlikely(segnum >= nilfs_sufile_get_nsegments(sufile))) {
491
-
printk(KERN_WARNING "%s: invalid segment number: %llu\n",
492
-
__func__, (unsigned long long)segnum);
493
-
return -EINVAL;
494
-
}
495
-
down_write(&NILFS_MDT(sufile)->mi_sem);
496
-
497
-
ret = nilfs_sufile_get_header_block(sufile, &header_bh);
498
-
if (ret < 0)
499
-
goto out_sem;
500
-
ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &su_bh);
501
-
if (ret < 0)
502
-
goto out_header;
509
+
int suclean;
503
510
504
511
kaddr = kmap_atomic(su_bh->b_page, KM_USER0);
505
512
su = nilfs_sufile_block_get_segment_usage(sufile, segnum, su_bh, kaddr);
506
513
if (nilfs_segment_usage_error(su)) {
507
514
kunmap_atomic(kaddr, KM_USER0);
508
-
brelse(su_bh);
509
-
goto out_header;
515
+
return;
510
516
}
511
-
517
+
suclean = nilfs_segment_usage_clean(su);
512
518
nilfs_segment_usage_set_error(su);
513
519
kunmap_atomic(kaddr, KM_USER0);
514
-
brelse(su_bh);
515
520
516
-
kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
517
-
header = nilfs_sufile_block_get_header(sufile, header_bh, kaddr);
518
-
le64_add_cpu(&header->sh_ndirtysegs, -1);
519
-
kunmap_atomic(kaddr, KM_USER0);
520
-
nilfs_mdt_mark_buffer_dirty(header_bh);
521
+
if (suclean)
522
+
nilfs_sufile_mod_counter(header_bh, -1, 0);
521
523
nilfs_mdt_mark_buffer_dirty(su_bh);
522
524
nilfs_mdt_mark_dirty(sufile);
523
-
brelse(su_bh);
524
-
525
-
out_header:
526
-
brelse(header_bh);
527
-
528
-
out_sem:
529
-
up_write(&NILFS_MDT(sufile)->mi_sem);
530
-
return ret;
531
525
}
532
526
533
527
/**
···
543
625
si[i + j].sui_nblocks = le32_to_cpu(su->su_nblocks);
544
626
si[i + j].sui_flags = le32_to_cpu(su->su_flags) &
545
627
~(1UL << NILFS_SEGMENT_USAGE_ACTIVE);
546
-
if (nilfs_segment_is_active(nilfs, segnum + i + j))
628
+
if (nilfs_segment_is_active(nilfs, segnum + j))
547
629
si[i + j].sui_flags |=
548
630
(1UL << NILFS_SEGMENT_USAGE_ACTIVE);
549
631
}
+75
-4
fs/nilfs2/sufile.h
+75
-4
fs/nilfs2/sufile.h
···
36
36
}
37
37
38
38
int nilfs_sufile_alloc(struct inode *, __u64 *);
39
-
int nilfs_sufile_cancel_free(struct inode *, __u64);
40
-
int nilfs_sufile_freev(struct inode *, __u64 *, size_t);
41
-
int nilfs_sufile_free(struct inode *, __u64);
42
39
int nilfs_sufile_get_segment_usage(struct inode *, __u64,
43
40
struct nilfs_segment_usage **,
44
41
struct buffer_head **);
···
43
46
struct buffer_head *);
44
47
int nilfs_sufile_get_stat(struct inode *, struct nilfs_sustat *);
45
48
int nilfs_sufile_get_ncleansegs(struct inode *, unsigned long *);
46
-
int nilfs_sufile_set_error(struct inode *, __u64);
47
49
ssize_t nilfs_sufile_get_suinfo(struct inode *, __u64, struct nilfs_suinfo *,
48
50
size_t);
49
51
52
+
int nilfs_sufile_update(struct inode *, __u64, int,
53
+
void (*dofunc)(struct inode *, __u64,
54
+
struct buffer_head *,
55
+
struct buffer_head *));
56
+
void nilfs_sufile_do_cancel_free(struct inode *, __u64, struct buffer_head *,
57
+
struct buffer_head *);
58
+
void nilfs_sufile_do_scrap(struct inode *, __u64, struct buffer_head *,
59
+
struct buffer_head *);
60
+
void nilfs_sufile_do_free(struct inode *, __u64, struct buffer_head *,
61
+
struct buffer_head *);
62
+
void nilfs_sufile_do_set_error(struct inode *, __u64, struct buffer_head *,
63
+
struct buffer_head *);
64
+
65
+
/**
66
+
* nilfs_sufile_cancel_free -
67
+
* @sufile: inode of segment usage file
68
+
* @segnum: segment number
69
+
*
70
+
* Description:
71
+
*
72
+
* Return Value: On success, 0 is returned. On error, one of the following
73
+
* negative error codes is returned.
74
+
*
75
+
* %-EIO - I/O error.
76
+
*
77
+
* %-ENOMEM - Insufficient amount of memory available.
78
+
*/
79
+
static inline int nilfs_sufile_cancel_free(struct inode *sufile, __u64 segnum)
80
+
{
81
+
return nilfs_sufile_update(sufile, segnum, 0,
82
+
nilfs_sufile_do_cancel_free);
83
+
}
84
+
85
+
/**
86
+
* nilfs_sufile_scrap - make a segment garbage
87
+
* @sufile: inode of segment usage file
88
+
* @segnum: segment number to be freed
89
+
*/
90
+
static inline int nilfs_sufile_scrap(struct inode *sufile, __u64 segnum)
91
+
{
92
+
return nilfs_sufile_update(sufile, segnum, 1, nilfs_sufile_do_scrap);
93
+
}
94
+
95
+
/**
96
+
* nilfs_sufile_free - free segment
97
+
* @sufile: inode of segment usage file
98
+
* @segnum: segment number to be freed
99
+
*/
100
+
static inline int nilfs_sufile_free(struct inode *sufile, __u64 segnum)
101
+
{
102
+
return nilfs_sufile_update(sufile, segnum, 0, nilfs_sufile_do_free);
103
+
}
104
+
105
+
/**
106
+
* nilfs_sufile_set_error - mark a segment as erroneous
107
+
* @sufile: inode of segment usage file
108
+
* @segnum: segment number
109
+
*
110
+
* Description: nilfs_sufile_set_error() marks the segment specified by
111
+
* @segnum as erroneous. The error segment will never be used again.
112
+
*
113
+
* Return Value: On success, 0 is returned. On error, one of the following
114
+
* negative error codes is returned.
115
+
*
116
+
* %-EIO - I/O error.
117
+
*
118
+
* %-ENOMEM - Insufficient amount of memory available.
119
+
*
120
+
* %-EINVAL - Invalid segment usage number.
121
+
*/
122
+
static inline int nilfs_sufile_set_error(struct inode *sufile, __u64 segnum)
123
+
{
124
+
return nilfs_sufile_update(sufile, segnum, 0,
125
+
nilfs_sufile_do_set_error);
126
+
}
50
127
51
128
#endif /* _NILFS_SUFILE_H */
+5
-2
fs/nilfs2/super.c
+5
-2
fs/nilfs2/super.c
···
63
63
MODULE_AUTHOR("NTT Corp.");
64
64
MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem "
65
65
"(NILFS)");
66
-
MODULE_VERSION(NILFS_VERSION);
67
66
MODULE_LICENSE("GPL");
68
67
69
68
static int nilfs_remount(struct super_block *sb, int *flags, char *data);
···
475
476
{
476
477
struct super_block *sb = dentry->d_sb;
477
478
struct nilfs_sb_info *sbi = NILFS_SB(sb);
479
+
struct the_nilfs *nilfs = sbi->s_nilfs;
480
+
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
478
481
unsigned long long blocks;
479
482
unsigned long overhead;
480
483
unsigned long nrsvblocks;
481
484
sector_t nfreeblocks;
482
-
struct the_nilfs *nilfs = sbi->s_nilfs;
483
485
int err;
484
486
485
487
/*
···
514
514
buf->f_files = atomic_read(&sbi->s_inodes_count);
515
515
buf->f_ffree = 0; /* nilfs_count_free_inodes(sb); */
516
516
buf->f_namelen = NILFS_NAME_LEN;
517
+
buf->f_fsid.val[0] = (u32)id;
518
+
buf->f_fsid.val[1] = (u32)(id >> 32);
519
+
517
520
return 0;
518
521
}
519
522
+4
fs/nilfs2/the_nilfs.c
+4
fs/nilfs2/the_nilfs.c
···
115
115
static int nilfs_load_super_root(struct the_nilfs *nilfs,
116
116
struct nilfs_sb_info *sbi, sector_t sr_block)
117
117
{
118
+
static struct lock_class_key dat_lock_key;
118
119
struct buffer_head *bh_sr;
119
120
struct nilfs_super_root *raw_sr;
120
121
struct nilfs_super_block **sbp = nilfs->ns_sbp;
···
163
162
err = nilfs_palloc_init_blockgroup(nilfs->ns_gc_dat, dat_entry_size);
164
163
if (unlikely(err))
165
164
goto failed_sufile;
165
+
166
+
lockdep_set_class(&NILFS_MDT(nilfs->ns_dat)->mi_sem, &dat_lock_key);
167
+
lockdep_set_class(&NILFS_MDT(nilfs->ns_gc_dat)->mi_sem, &dat_lock_key);
166
168
167
169
nilfs_mdt_set_shadow(nilfs->ns_dat, nilfs->ns_gc_dat);
168
170
nilfs_mdt_set_entry_size(nilfs->ns_cpfile, checkpoint_size,