* [dhowells-fs:netfs-next-5 22/29] fs/netfs/write_issue.c:437:25: error: implicit declaration of function 'mempool_alloc'; did you mean 'mm_alloc'?
@ 2026-10-02 0:38 kernel test robot
0 siblings, 0 replies; 2+ messages in thread
From: kernel test robot @ 2026-10-02 0:38 UTC (permalink / raw)
To: David Howells; +Cc: oe-kbuild-all
tree: https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git netfs-next-5
head: 5c15345b43019adfd7a82be7f4f190a37dd19310
commit: f7fd91dc74af6deec31273b2157ba5d0334c031d [22/29] netfs: Build a list of regions undergoing writeback
config: microblaze-defconfig (https://download.01.org/0day-ci/archive/20261002/202610020808.zkGjqA2Z-lkp@intel.com/config)
compiler: microblaze-linux-gcc (GCC) 16.1.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20261002/202610020808.zkGjqA2Z-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202610020808.zkGjqA2Z-lkp@intel.com/
All errors (new ones prefixed by >>):
fs/netfs/write_issue.c: In function 'netfs_write_folio':
>> fs/netfs/write_issue.c:437:25: error: implicit declaration of function 'mempool_alloc'; did you mean 'mm_alloc'? [-Wimplicit-function-declaration]
437 | wback = mempool_alloc(&netfs_writeback_pool, wreq->gfp);
| ^~~~~~~~~~~~~
| mm_alloc
fs/netfs/write_issue.c:437:23: error: assignment to 'struct netfs_writeback *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
437 | wback = mempool_alloc(&netfs_writeback_pool, wreq->gfp);
| ^
vim +437 fs/netfs/write_issue.c
324
325 /*
326 * Write some of a pending folio data back to the server.
327 */
328 static int netfs_write_folio(struct netfs_io_request *wreq,
329 struct writeback_control *wbc,
330 struct folio *folio)
331 {
332 struct netfs_io_stream *upload = &wreq->io_streams[0];
333 struct netfs_io_stream *cache = &wreq->io_streams[1];
334 struct netfs_io_stream *stream;
335 struct netfs_writeback *wback;
336 struct netfs_group *fgroup; /* TODO: Use this with ceph */
337 struct netfs_folio *finfo;
338 struct bvecq *queue = wreq->load_cursor.bvecq;
339 unsigned int slot;
340 size_t fsize = folio_size(folio), flen = fsize, foff = 0;
341 uoff_t fpos = folio_pos(folio), i_size;
342 bool to_eof = false, streamw = false;
343 bool debug = false;
344
345 _enter("");
346
347 if (!wreq->spare) {
348 wreq->spare = bvecq_alloc_one(BVECQ_POOL_SLOTS, wreq->gfp, true);
349 if (!wreq->spare)
350 return -ENOMEM;
351 }
352
353 /* netfs_perform_write() may shift i_size around the folio or from out
354 * of the folio to beyond it, but cannot move i_size into or through
355 * the folio since we have it locked.
356 *
357 * Truncate could in theory move i_size into or before the folio, but
358 * it should take steps to prevent writeback from happening
359 * concurrently and should wait for any in-progress writebacks before
360 * proceeding.
361 */
362 i_size = i_size_read(wreq->inode);
363
364 if (fpos >= i_size) {
365 /* mmap beyond eof. */
366 _debug("beyond eof");
367 folio_start_writeback(folio);
368 folio_unlock(folio);
369 wreq->nr_group_rel += netfs_folio_written_back(folio);
370 netfs_put_group_many(wreq->group, wreq->nr_group_rel);
371 wreq->nr_group_rel = 0;
372 return 0;
373 }
374
375 if (fpos + fsize > wreq->i_size)
376 wreq->i_size = i_size;
377
378 fgroup = netfs_folio_group(folio);
379 finfo = netfs_folio_info(folio);
380 if (finfo) {
381 foff = finfo->dirty_offset;
382 flen = foff + finfo->dirty_len;
383 streamw = true;
384 }
385
386 if (flen > i_size - fpos) {
387 flen = i_size - fpos;
388 if (!streamw)
389 folio_zero_segment(folio, flen, fsize);
390 to_eof = true;
391 } else if (flen == i_size - fpos) {
392 to_eof = true;
393 }
394 flen -= foff;
395
396 _debug("folio %zx %zx %zx", foff, flen, fsize);
397
398 /* Deal with discontinuities in the stream of dirty pages. These can
399 * arise from a number of sources:
400 *
401 * (1) Intervening non-dirty pages from random-access writes, multiple
402 * flushers writing back different parts simultaneously and manual
403 * syncing.
404 *
405 * (2) Partially-written pages from write-streaming.
406 *
407 * (3) Pages that belong to a different write-back group (eg. Ceph
408 * snapshots).
409 *
410 * (4) Actually-clean pages that were marked for write to the cache
411 * when they were read. Note that these appear as a special
412 * write-back group.
413 */
414 if (fgroup == NETFS_FOLIO_COPY_TO_CACHE) {
415 netfs_issue_write(wreq, upload);
416 } else if (fgroup != wreq->group) {
417 /* We can't write this page to the server yet. */
418 kdebug("wrong group");
419 folio_redirty_for_writepage(wbc, folio);
420 folio_unlock(folio);
421 netfs_issue_write(wreq, upload);
422 netfs_issue_write(wreq, cache);
423 return 0;
424 }
425
426 if (foff > 0)
427 netfs_issue_write(wreq, upload);
428 if (streamw)
429 netfs_issue_write(wreq, cache);
430
431 folio_start_writeback(folio);
432 folio_unlock(folio);
433
434 /* Keep track of what we will need to unlock. */
435 wback = wreq->writebacks_tail;
436 if (!wback || fpos != wback->start + wback->len || wback->len > LONG_MAX) {
> 437 wback = mempool_alloc(&netfs_writeback_pool, wreq->gfp);
438 wback->next = NULL;
439 wback->start = fpos;
440 wback->len = fsize;
441
442 if (wreq->writebacks)
443 /* Order write of next after last write of len in old tail. */
444 smp_store_release(&wreq->writebacks_tail->next, wback);
445 else
446 wreq->writebacks = wback;
447 wreq->writebacks_tail = wback;
448 } else {
449 /* Order update of len after setting pointer. */
450 smp_store_release(&wback->len, wback->len + fsize);
451 }
452
453 if (fgroup == NETFS_FOLIO_COPY_TO_CACHE) {
454 if (!cache->avail) {
455 trace_netfs_folio(folio, netfs_folio_trace_cancel_copy);
456 netfs_issue_write(wreq, upload);
457 netfs_folio_written_back(folio);
458 return 0;
459 }
460 trace_netfs_folio(folio, netfs_folio_trace_store_copy);
461 } else if (!upload->avail && !cache->avail) {
462 trace_netfs_folio(folio, netfs_folio_trace_cancel_store);
463 netfs_folio_written_back(folio);
464 return 0;
465 } else if (!upload->construct) {
466 trace_netfs_folio(folio, netfs_folio_trace_store);
467 } else {
468 trace_netfs_folio(folio, netfs_folio_trace_store_plus);
469 }
470
471 /* Institute a new bvec queue segment if the current one is full or if
472 * we encounter a discontiguity. The discontiguity break is important
473 * when it comes to bulk unlocking folios by file range.
474 */
475 if (bvecq_is_full(queue) ||
476 (fpos != wreq->last_end && wreq->last_end > 0)) {
477 bvecq_buffer_append(&wreq->load_cursor, wreq->spare);
478 wreq->spare = NULL;
479
480 queue = wreq->load_cursor.bvecq;
481 bvecq_pos_move(&wreq->dispatch_cursor, queue);
482 wreq->dispatch_cursor.slot = 0;
483 }
484
485 /* Attach the folio to the rolling buffer. */
486 slot = queue->nr_slots;
487 bvec_set_folio(&queue->bv[slot], folio, fsize, 0);
488 trace_netfs_bv_slot(queue, slot);
489 slot++;
490 bvecq_filled_to(queue, slot);
491 wreq->load_cursor.slot = slot;
492 wreq->load_cursor.offset = 0;
493 wreq->last_end = fpos + fsize;
494
495 /* Move the submission point forward to allow for write-streaming data
496 * not starting at the front of the page. We don't do write-streaming
497 * with the cache as the cache requires DIO alignment.
498 *
499 * Also skip uploading for data that's been read and just needs copying
500 * to the cache.
501 */
502 bvecq_pos_nudge(&wreq->dispatch_cursor);
503
504 for (int s = 0; s < NR_IO_STREAMS; s++) {
505 size_t soff = foff, slen = flen, alignment = 1;
506
507 stream = &wreq->io_streams[s];
508 if (stream->source == NETFS_WRITE_TO_CACHE)
509 alignment = wreq->cache_resources.dio_size;
510 stream = &wreq->io_streams[s];
511 stream->submit_off = round_down(soff, alignment);
512 slen += foff - stream->submit_off;
513 stream->submit_len = round_up(slen, alignment);
514
515 if (!stream->avail ||
516 (stream->source == NETFS_WRITE_TO_CACHE && streamw) ||
517 (stream->source == NETFS_UPLOAD_TO_SERVER &&
518 fgroup == NETFS_FOLIO_COPY_TO_CACHE)) {
519 stream->submit_off = UINT_MAX;
520 stream->submit_len = 0;
521 }
522 }
523
524 /* Attach the folio to one or more subrequests. For a big folio, we
525 * could end up with thousands of subrequests if the wsize is small -
526 * but we might need to wait during the creation of subrequests for
527 * network resources (eg. SMB credits).
528 */
529 for (;;) {
530 ssize_t part;
531 size_t lowest_off = ULONG_MAX;
532 int choose_s = -1;
533
534 /* Always add to the lowest-submitted stream first. */
535 for (int s = 0; s < NR_IO_STREAMS; s++) {
536 stream = &wreq->io_streams[s];
537 if (stream->submit_len > 0 &&
538 stream->submit_off < lowest_off) {
539 lowest_off = stream->submit_off;
540 choose_s = s;
541 }
542 }
543
544 if (choose_s < 0)
545 break;
546 stream = &wreq->io_streams[choose_s];
547
548 /* Advance the cursor. */
549 wreq->dispatch_cursor.offset = stream->submit_off;
550
551 atomic64_set(&wreq->issued_to, fpos + stream->submit_off);
552 part = netfs_advance_write(wreq, stream, fpos + stream->submit_off,
553 stream->submit_len, to_eof);
554 stream->submit_off += part;
555 if (part > stream->submit_len)
556 stream->submit_len = 0;
557 else
558 stream->submit_len -= part;
559 if (part > 0)
560 debug = true;
561 }
562
563 bvecq_pos_step(&wreq->dispatch_cursor);
564 /* Order loading the queue before updating the issue_to point */
565 atomic64_set_release(&wreq->issued_to, fpos + fsize);
566
567 if (!debug)
568 kdebug("R=%x: No submit", wreq->debug_id);
569
570 if (foff + flen < fsize)
571 for (int s = 0; s < NR_IO_STREAMS; s++)
572 netfs_issue_write(wreq, &wreq->io_streams[s]);
573
574 _leave(" = 0");
575 return 0;
576 }
577
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 2+ messages in thread
* [dhowells-fs:netfs-next-5 22/29] fs/netfs/write_issue.c:437:25: error: implicit declaration of function 'mempool_alloc'; did you mean 'mm_alloc'?
@ 2026-10-02 6:22 kernel test robot
0 siblings, 0 replies; 2+ messages in thread
From: kernel test robot @ 2026-10-02 6:22 UTC (permalink / raw)
To: David Howells; +Cc: oe-kbuild-all
tree: https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git netfs-next-5
head: 8e1336a514c9296d8cb62fa11d6fa8b6f6117c9f
commit: f7fd91dc74af6deec31273b2157ba5d0334c031d [22/29] netfs: Build a list of regions undergoing writeback
config: i386-randconfig-r2103-20261001 (https://download.01.org/0day-ci/archive/20261002/202610020805.Qpxd0UNZ-lkp@intel.com/config)
compiler: gcc-14 (Debian 14.2.0-19) 14.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20261002/202610020805.Qpxd0UNZ-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202610020805.Qpxd0UNZ-lkp@intel.com/
All errors (new ones prefixed by >>):
fs/netfs/write_issue.c: In function 'netfs_write_folio':
>> fs/netfs/write_issue.c:437:25: error: implicit declaration of function 'mempool_alloc'; did you mean 'mm_alloc'? [-Wimplicit-function-declaration]
437 | wback = mempool_alloc(&netfs_writeback_pool, wreq->gfp);
| ^~~~~~~~~~~~~
| mm_alloc
fs/netfs/write_issue.c:437:23: error: assignment to 'struct netfs_writeback *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
437 | wback = mempool_alloc(&netfs_writeback_pool, wreq->gfp);
| ^
vim +437 fs/netfs/write_issue.c
324
325 /*
326 * Write some of a pending folio data back to the server.
327 */
328 static int netfs_write_folio(struct netfs_io_request *wreq,
329 struct writeback_control *wbc,
330 struct folio *folio)
331 {
332 struct netfs_io_stream *upload = &wreq->io_streams[0];
333 struct netfs_io_stream *cache = &wreq->io_streams[1];
334 struct netfs_io_stream *stream;
335 struct netfs_writeback *wback;
336 struct netfs_group *fgroup; /* TODO: Use this with ceph */
337 struct netfs_folio *finfo;
338 struct bvecq *queue = wreq->load_cursor.bvecq;
339 unsigned int slot;
340 size_t fsize = folio_size(folio), flen = fsize, foff = 0;
341 uoff_t fpos = folio_pos(folio), i_size;
342 bool to_eof = false, streamw = false;
343 bool debug = false;
344
345 _enter("");
346
347 if (!wreq->spare) {
348 wreq->spare = bvecq_alloc_one(BVECQ_POOL_SLOTS, wreq->gfp, true);
349 if (!wreq->spare)
350 return -ENOMEM;
351 }
352
353 /* netfs_perform_write() may shift i_size around the folio or from out
354 * of the folio to beyond it, but cannot move i_size into or through
355 * the folio since we have it locked.
356 *
357 * Truncate could in theory move i_size into or before the folio, but
358 * it should take steps to prevent writeback from happening
359 * concurrently and should wait for any in-progress writebacks before
360 * proceeding.
361 */
362 i_size = i_size_read(wreq->inode);
363
364 if (fpos >= i_size) {
365 /* mmap beyond eof. */
366 _debug("beyond eof");
367 folio_start_writeback(folio);
368 folio_unlock(folio);
369 wreq->nr_group_rel += netfs_folio_written_back(folio);
370 netfs_put_group_many(wreq->group, wreq->nr_group_rel);
371 wreq->nr_group_rel = 0;
372 return 0;
373 }
374
375 if (fpos + fsize > wreq->i_size)
376 wreq->i_size = i_size;
377
378 fgroup = netfs_folio_group(folio);
379 finfo = netfs_folio_info(folio);
380 if (finfo) {
381 foff = finfo->dirty_offset;
382 flen = foff + finfo->dirty_len;
383 streamw = true;
384 }
385
386 if (flen > i_size - fpos) {
387 flen = i_size - fpos;
388 if (!streamw)
389 folio_zero_segment(folio, flen, fsize);
390 to_eof = true;
391 } else if (flen == i_size - fpos) {
392 to_eof = true;
393 }
394 flen -= foff;
395
396 _debug("folio %zx %zx %zx", foff, flen, fsize);
397
398 /* Deal with discontinuities in the stream of dirty pages. These can
399 * arise from a number of sources:
400 *
401 * (1) Intervening non-dirty pages from random-access writes, multiple
402 * flushers writing back different parts simultaneously and manual
403 * syncing.
404 *
405 * (2) Partially-written pages from write-streaming.
406 *
407 * (3) Pages that belong to a different write-back group (eg. Ceph
408 * snapshots).
409 *
410 * (4) Actually-clean pages that were marked for write to the cache
411 * when they were read. Note that these appear as a special
412 * write-back group.
413 */
414 if (fgroup == NETFS_FOLIO_COPY_TO_CACHE) {
415 netfs_issue_write(wreq, upload);
416 } else if (fgroup != wreq->group) {
417 /* We can't write this page to the server yet. */
418 kdebug("wrong group");
419 folio_redirty_for_writepage(wbc, folio);
420 folio_unlock(folio);
421 netfs_issue_write(wreq, upload);
422 netfs_issue_write(wreq, cache);
423 return 0;
424 }
425
426 if (foff > 0)
427 netfs_issue_write(wreq, upload);
428 if (streamw)
429 netfs_issue_write(wreq, cache);
430
431 folio_start_writeback(folio);
432 folio_unlock(folio);
433
434 /* Keep track of what we will need to unlock. */
435 wback = wreq->writebacks_tail;
436 if (!wback || fpos != wback->start + wback->len || wback->len > LONG_MAX) {
> 437 wback = mempool_alloc(&netfs_writeback_pool, wreq->gfp);
438 wback->next = NULL;
439 wback->start = fpos;
440 wback->len = fsize;
441
442 if (wreq->writebacks)
443 /* Order write of next after last write of len in old tail. */
444 smp_store_release(&wreq->writebacks_tail->next, wback);
445 else
446 wreq->writebacks = wback;
447 wreq->writebacks_tail = wback;
448 } else {
449 /* Order update of len after setting pointer. */
450 smp_store_release(&wback->len, wback->len + fsize);
451 }
452
453 if (fgroup == NETFS_FOLIO_COPY_TO_CACHE) {
454 if (!cache->avail) {
455 trace_netfs_folio(folio, netfs_folio_trace_cancel_copy);
456 netfs_issue_write(wreq, upload);
457 netfs_folio_written_back(folio);
458 return 0;
459 }
460 trace_netfs_folio(folio, netfs_folio_trace_store_copy);
461 } else if (!upload->avail && !cache->avail) {
462 trace_netfs_folio(folio, netfs_folio_trace_cancel_store);
463 netfs_folio_written_back(folio);
464 return 0;
465 } else if (!upload->construct) {
466 trace_netfs_folio(folio, netfs_folio_trace_store);
467 } else {
468 trace_netfs_folio(folio, netfs_folio_trace_store_plus);
469 }
470
471 /* Institute a new bvec queue segment if the current one is full or if
472 * we encounter a discontiguity. The discontiguity break is important
473 * when it comes to bulk unlocking folios by file range.
474 */
475 if (bvecq_is_full(queue) ||
476 (fpos != wreq->last_end && wreq->last_end > 0)) {
477 bvecq_buffer_append(&wreq->load_cursor, wreq->spare);
478 wreq->spare = NULL;
479
480 queue = wreq->load_cursor.bvecq;
481 bvecq_pos_move(&wreq->dispatch_cursor, queue);
482 wreq->dispatch_cursor.slot = 0;
483 }
484
485 /* Attach the folio to the rolling buffer. */
486 slot = queue->nr_slots;
487 bvec_set_folio(&queue->bv[slot], folio, fsize, 0);
488 trace_netfs_bv_slot(queue, slot);
489 slot++;
490 bvecq_filled_to(queue, slot);
491 wreq->load_cursor.slot = slot;
492 wreq->load_cursor.offset = 0;
493 wreq->last_end = fpos + fsize;
494
495 /* Move the submission point forward to allow for write-streaming data
496 * not starting at the front of the page. We don't do write-streaming
497 * with the cache as the cache requires DIO alignment.
498 *
499 * Also skip uploading for data that's been read and just needs copying
500 * to the cache.
501 */
502 bvecq_pos_nudge(&wreq->dispatch_cursor);
503
504 for (int s = 0; s < NR_IO_STREAMS; s++) {
505 size_t soff = foff, slen = flen, alignment = 1;
506
507 stream = &wreq->io_streams[s];
508 if (stream->source == NETFS_WRITE_TO_CACHE)
509 alignment = wreq->cache_resources.dio_size;
510 stream = &wreq->io_streams[s];
511 stream->submit_off = round_down(soff, alignment);
512 slen += foff - stream->submit_off;
513 stream->submit_len = round_up(slen, alignment);
514
515 if (!stream->avail ||
516 (stream->source == NETFS_WRITE_TO_CACHE && streamw) ||
517 (stream->source == NETFS_UPLOAD_TO_SERVER &&
518 fgroup == NETFS_FOLIO_COPY_TO_CACHE)) {
519 stream->submit_off = UINT_MAX;
520 stream->submit_len = 0;
521 }
522 }
523
524 /* Attach the folio to one or more subrequests. For a big folio, we
525 * could end up with thousands of subrequests if the wsize is small -
526 * but we might need to wait during the creation of subrequests for
527 * network resources (eg. SMB credits).
528 */
529 for (;;) {
530 ssize_t part;
531 size_t lowest_off = ULONG_MAX;
532 int choose_s = -1;
533
534 /* Always add to the lowest-submitted stream first. */
535 for (int s = 0; s < NR_IO_STREAMS; s++) {
536 stream = &wreq->io_streams[s];
537 if (stream->submit_len > 0 &&
538 stream->submit_off < lowest_off) {
539 lowest_off = stream->submit_off;
540 choose_s = s;
541 }
542 }
543
544 if (choose_s < 0)
545 break;
546 stream = &wreq->io_streams[choose_s];
547
548 /* Advance the cursor. */
549 wreq->dispatch_cursor.offset = stream->submit_off;
550
551 atomic64_set(&wreq->issued_to, fpos + stream->submit_off);
552 part = netfs_advance_write(wreq, stream, fpos + stream->submit_off,
553 stream->submit_len, to_eof);
554 stream->submit_off += part;
555 if (part > stream->submit_len)
556 stream->submit_len = 0;
557 else
558 stream->submit_len -= part;
559 if (part > 0)
560 debug = true;
561 }
562
563 bvecq_pos_step(&wreq->dispatch_cursor);
564 /* Order loading the queue before updating the issue_to point */
565 atomic64_set_release(&wreq->issued_to, fpos + fsize);
566
567 if (!debug)
568 kdebug("R=%x: No submit", wreq->debug_id);
569
570 if (foff + flen < fsize)
571 for (int s = 0; s < NR_IO_STREAMS; s++)
572 netfs_issue_write(wreq, &wreq->io_streams[s]);
573
574 _leave(" = 0");
575 return 0;
576 }
577
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-10-02 6:22 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-10-02 6:22 [dhowells-fs:netfs-next-5 22/29] fs/netfs/write_issue.c:437:25: error: implicit declaration of function 'mempool_alloc'; did you mean 'mm_alloc'? kernel test robot
-- strict thread matches above, loose matches on Subject: below --
2026-10-02 0:38 kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.