Hello Namjae Jeon,
The patch 96ad4ec51c06: "ksmbd: fix unused err value in smb2_lock"
from Jul 13, 2021, leads to the following static checker warning:
fs/ksmbd/smb2pdu.c:6565 smb2_lock()
warn: missing error code here? 'smb_flock_init()' failed.
fs/ksmbd/smb2pdu.c
6518 int smb2_lock(struct ksmbd_work *work)
6519 {
6520 struct smb2_lock_req *req = work->request_buf;
6521 struct smb2_lock_rsp *rsp = work->response_buf;
6522 struct smb2_lock_element *lock_ele;
6523 struct ksmbd_file *fp = NULL;
6524 struct file_lock *flock = NULL;
6525 struct file *filp = NULL;
6526 int lock_count;
6527 int flags = 0;
6528 int cmd = 0;
6529 int err = 0, i;
6530 u64 lock_start, lock_length;
6531 struct ksmbd_lock *smb_lock = NULL, *cmp_lock, *tmp, *tmp2;
6532 struct ksmbd_conn *conn;
6533 int nolock = 0;
6534 LIST_HEAD(lock_list);
6535 LIST_HEAD(rollback_list);
6536 int prior_lock = 0;
6537
6538 ksmbd_debug(SMB, "Received lock request\n");
6539 fp = ksmbd_lookup_fd_slow(work,
6540 le64_to_cpu(req->VolatileFileId),
6541 le64_to_cpu(req->PersistentFileId));
6542 if (!fp) {
6543 ksmbd_debug(SMB, "Invalid file id for lock : %llu\n",
6544 le64_to_cpu(req->VolatileFileId));
6545 rsp->hdr.Status = STATUS_FILE_CLOSED;
6546 goto out2;
6547 }
6548
6549 filp = fp->filp;
6550 lock_count = le16_to_cpu(req->LockCount);
6551 lock_ele = req->locks;
6552
6553 ksmbd_debug(SMB, "lock count is %d\n", lock_count);
6554 if (!lock_count) {
6555 rsp->hdr.Status = STATUS_INVALID_PARAMETER;
6556 goto out2;
6557 }
6558
6559 for (i = 0; i < lock_count; i++) {
6560 flags = le32_to_cpu(lock_ele[i].Flags);
6561
6562 flock = smb_flock_init(filp);
6563 if (!flock) {
6564 rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
--> 6565 goto out;
^^^^^^^^
Should this be an error code?
6566 }
6567
6568 cmd = smb2_set_flock_flags(flock, flags);
6569
6570 lock_start = le64_to_cpu(lock_ele[i].Offset);
6571 lock_length = le64_to_cpu(lock_ele[i].Length);
6572 if (lock_start > U64_MAX - lock_length) {
6573 pr_err("Invalid lock range requested\n");
6574 rsp->hdr.Status = STATUS_INVALID_LOCK_RANGE;
6575 goto out;
Same for a bunch of these early gotos as well.
6576 }
6577
6578 if (lock_start > OFFSET_MAX)
6579 flock->fl_start = OFFSET_MAX;
6580 else
6581 flock->fl_start = lock_start;
6582
6583 lock_length = le64_to_cpu(lock_ele[i].Length);
6584 if (lock_length > OFFSET_MAX - flock->fl_start)
6585 lock_length = OFFSET_MAX - flock->fl_start;
6586
6587 flock->fl_end = flock->fl_start + lock_length;
6588
6589 if (flock->fl_end < flock->fl_start) {
6590 ksmbd_debug(SMB,
6591 "the end offset(%llx) is smaller than the start offset(%llx)\n",
6592 flock->fl_end, flock->fl_start);
6593 rsp->hdr.Status = STATUS_INVALID_LOCK_RANGE;
6594 goto out;
6595 }
6596
6597 /* Check conflict locks in one request */
6598 list_for_each_entry(cmp_lock, &lock_list, llist) {
6599 if (cmp_lock->fl->fl_start <= flock->fl_start &&
6600 cmp_lock->fl->fl_end >= flock->fl_end) {
6601 if (cmp_lock->fl->fl_type != F_UNLCK &&
6602 flock->fl_type != F_UNLCK) {
6603 pr_err("conflict two locks in one request\n");
6604 rsp->hdr.Status =
6605 STATUS_INVALID_PARAMETER;
6606 goto out;
6607 }
6608 }
6609 }
6610
6611 smb_lock = smb2_lock_init(flock, cmd, flags, &lock_list);
6612 if (!smb_lock) {
6613 rsp->hdr.Status = STATUS_INVALID_PARAMETER;
6614 goto out;
6615 }
6616 }
6617
6618 list_for_each_entry_safe(smb_lock, tmp, &lock_list, llist) {
6619 if (smb_lock->cmd < 0) {
6620 rsp->hdr.Status = STATUS_INVALID_PARAMETER;
6621 goto out;
6622 }
6623
6624 if (!(smb_lock->flags & SMB2_LOCKFLAG_MASK)) {
6625 rsp->hdr.Status = STATUS_INVALID_PARAMETER;
6626 goto out;
6627 }
6628
6629 if ((prior_lock & (SMB2_LOCKFLAG_EXCLUSIVE | SMB2_LOCKFLAG_SHARED) &&
6630 smb_lock->flags & SMB2_LOCKFLAG_UNLOCK) ||
6631 (prior_lock == SMB2_LOCKFLAG_UNLOCK &&
6632 !(smb_lock->flags & SMB2_LOCKFLAG_UNLOCK))) {
6633 rsp->hdr.Status = STATUS_INVALID_PARAMETER;
6634 goto out;
6635 }
6636
6637 prior_lock = smb_lock->flags;
6638
6639 if (!(smb_lock->flags & SMB2_LOCKFLAG_UNLOCK) &&
6640 !(smb_lock->flags & SMB2_LOCKFLAG_FAIL_IMMEDIATELY))
6641 goto no_check_cl;
6642
6643 nolock = 1;
6644 /* check locks in connection list */
6645 read_lock(&conn_list_lock);
6646 list_for_each_entry(conn, &conn_list, conns_list) {
6647 spin_lock(&conn->llist_lock);
6648 list_for_each_entry_safe(cmp_lock, tmp2, &conn->lock_list, clist) {
6649 if (file_inode(cmp_lock->fl->fl_file) !=
6650 file_inode(smb_lock->fl->fl_file))
6651 continue;
6652
6653 if (smb_lock->fl->fl_type == F_UNLCK) {
6654 if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file &&
6655 cmp_lock->start == smb_lock->start &&
6656 cmp_lock->end == smb_lock->end &&
6657 !lock_defer_pending(cmp_lock->fl)) {
6658 nolock = 0;
6659 list_del(&cmp_lock->flist);
6660 list_del(&cmp_lock->clist);
6661 spin_unlock(&conn->llist_lock);
6662 read_unlock(&conn_list_lock);
6663
6664 locks_free_lock(cmp_lock->fl);
6665 kfree(cmp_lock);
6666 goto out_check_cl;
6667 }
6668 continue;
6669 }
6670
6671 if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file) {
6672 if (smb_lock->flags & SMB2_LOCKFLAG_SHARED)
6673 continue;
6674 } else {
6675 if (cmp_lock->flags & SMB2_LOCKFLAG_SHARED)
6676 continue;
6677 }
6678
6679 /* check zero byte lock range */
6680 if (cmp_lock->zero_len && !smb_lock->zero_len &&
6681 cmp_lock->start > smb_lock->start &&
6682 cmp_lock->start < smb_lock->end) {
6683 spin_unlock(&conn->llist_lock);
6684 read_unlock(&conn_list_lock);
6685 pr_err("previous lock conflict with zero byte lock range\n");
6686 rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
6687 goto out;
6688 }
6689
6690 if (smb_lock->zero_len && !cmp_lock->zero_len &&
6691 smb_lock->start > cmp_lock->start &&
6692 smb_lock->start < cmp_lock->end) {
6693 spin_unlock(&conn->llist_lock);
6694 read_unlock(&conn_list_lock);
6695 pr_err("current lock conflict with zero byte lock range\n");
6696 rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
6697 goto out;
6698 }
6699
6700 if (((cmp_lock->start <= smb_lock->start &&
6701 cmp_lock->end > smb_lock->start) ||
6702 (cmp_lock->start < smb_lock->end &&
6703 cmp_lock->end >= smb_lock->end)) &&
6704 !cmp_lock->zero_len && !smb_lock->zero_len) {
6705 spin_unlock(&conn->llist_lock);
6706 read_unlock(&conn_list_lock);
6707 pr_err("Not allow lock operation on exclusive lock range\n");
6708 rsp->hdr.Status =
6709 STATUS_LOCK_NOT_GRANTED;
6710 goto out;
6711 }
6712 }
6713 spin_unlock(&conn->llist_lock);
6714 }
6715 read_unlock(&conn_list_lock);
6716 out_check_cl:
6717 if (smb_lock->fl->fl_type == F_UNLCK && nolock) {
6718 pr_err("Try to unlock nolocked range\n");
6719 rsp->hdr.Status = STATUS_RANGE_NOT_LOCKED;
6720 goto out;
6721 }
6722
6723 no_check_cl:
6724 if (smb_lock->zero_len) {
6725 err = 0;
6726 goto skip;
6727 }
6728
6729 flock = smb_lock->fl;
6730 list_del(&smb_lock->llist);
6731 retry:
6732 err = vfs_lock_file(filp, smb_lock->cmd, flock, NULL);
6733 skip:
6734 if (flags & SMB2_LOCKFLAG_UNLOCK) {
6735 if (!err) {
6736 ksmbd_debug(SMB, "File unlocked\n");
6737 } else if (err == -ENOENT) {
6738 rsp->hdr.Status = STATUS_NOT_LOCKED;
6739 goto out;
6740 }
6741 locks_free_lock(flock);
6742 kfree(smb_lock);
6743 } else {
6744 if (err == FILE_LOCK_DEFERRED) {
6745 void **argv;
6746
6747 ksmbd_debug(SMB,
6748 "would have to wait for getting lock\n");
6749 spin_lock(&work->conn->llist_lock);
6750 list_add_tail(&smb_lock->clist,
6751 &work->conn->lock_list);
6752 spin_unlock(&work->conn->llist_lock);
6753 list_add(&smb_lock->llist, &rollback_list);
6754
6755 argv = kmalloc(sizeof(void *), GFP_KERNEL);
6756 if (!argv) {
6757 err = -ENOMEM;
6758 goto out;
6759 }
6760 argv[0] = flock;
6761
6762 err = setup_async_work(work,
6763 smb2_remove_blocked_lock,
6764 argv);
6765 if (err) {
6766 rsp->hdr.Status =
6767 STATUS_INSUFFICIENT_RESOURCES;
6768 goto out;
6769 }
6770 spin_lock(&fp->f_lock);
6771 list_add(&work->fp_entry, &fp->blocked_works);
6772 spin_unlock(&fp->f_lock);
6773
6774 smb2_send_interim_resp(work, STATUS_PENDING);
6775
6776 ksmbd_vfs_posix_lock_wait(flock);
6777
6778 if (work->state != KSMBD_WORK_ACTIVE) {
6779 list_del(&smb_lock->llist);
6780 spin_lock(&work->conn->llist_lock);
6781 list_del(&smb_lock->clist);
6782 spin_unlock(&work->conn->llist_lock);
6783 locks_free_lock(flock);
6784
6785 if (work->state == KSMBD_WORK_CANCELLED) {
6786 spin_lock(&fp->f_lock);
6787 list_del(&work->fp_entry);
6788 spin_unlock(&fp->f_lock);
6789 rsp->hdr.Status =
6790 STATUS_CANCELLED;
6791 kfree(smb_lock);
6792 smb2_send_interim_resp(work,
6793 STATUS_CANCELLED);
6794 work->send_no_response = 1;
6795 goto out;
6796 }
6797 init_smb2_rsp_hdr(work);
6798 smb2_set_err_rsp(work);
6799 rsp->hdr.Status =
6800 STATUS_RANGE_NOT_LOCKED;
6801 kfree(smb_lock);
6802 goto out2;
6803 }
6804
6805 list_del(&smb_lock->llist);
6806 spin_lock(&work->conn->llist_lock);
6807 list_del(&smb_lock->clist);
6808 spin_unlock(&work->conn->llist_lock);
6809
6810 spin_lock(&fp->f_lock);
6811 list_del(&work->fp_entry);
6812 spin_unlock(&fp->f_lock);
6813 goto retry;
6814 } else if (!err) {
6815 spin_lock(&work->conn->llist_lock);
6816 list_add_tail(&smb_lock->clist,
6817 &work->conn->lock_list);
6818 list_add_tail(&smb_lock->flist,
6819 &fp->lock_list);
6820 spin_unlock(&work->conn->llist_lock);
6821 list_add(&smb_lock->llist, &rollback_list);
6822 ksmbd_debug(SMB, "successful in taking lock\n");
6823 } else {
6824 rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
6825 goto out;
6826 }
6827 }
6828 }
6829
6830 if (atomic_read(&fp->f_ci->op_count) > 1)
6831 smb_break_all_oplock(work, fp);
6832
6833 rsp->StructureSize = cpu_to_le16(4);
6834 ksmbd_debug(SMB, "successful in taking lock\n");
6835 rsp->hdr.Status = STATUS_SUCCESS;
6836 rsp->Reserved = 0;
6837 inc_rfc1001_len(rsp, 4);
6838 ksmbd_fd_put(work, fp);
6839 return 0;
6840
6841 out:
6842 list_for_each_entry_safe(smb_lock, tmp, &lock_list, llist) {
6843 locks_free_lock(smb_lock->fl);
6844 list_del(&smb_lock->llist);
6845 kfree(smb_lock);
6846 }
6847
6848 list_for_each_entry_safe(smb_lock, tmp, &rollback_list, llist) {
6849 struct file_lock *rlock = NULL;
6850 int rc;
6851
6852 rlock = smb_flock_init(filp);
6853 rlock->fl_type = F_UNLCK;
6854 rlock->fl_start = smb_lock->start;
6855 rlock->fl_end = smb_lock->end;
6856
6857 rc = vfs_lock_file(filp, 0, rlock, NULL);
6858 if (rc)
6859 pr_err("rollback unlock fail : %d\n", rc);
6860
6861 list_del(&smb_lock->llist);
6862 spin_lock(&work->conn->llist_lock);
6863 if (!list_empty(&smb_lock->flist))
6864 list_del(&smb_lock->flist);
6865 list_del(&smb_lock->clist);
6866 spin_unlock(&work->conn->llist_lock);
6867
6868 locks_free_lock(smb_lock->fl);
6869 locks_free_lock(rlock);
6870 kfree(smb_lock);
6871 }
6872 out2:
6873 ksmbd_debug(SMB, "failed in taking lock(flags : %x)\n", flags);
6874 smb2_set_err_rsp(work);
6875 ksmbd_fd_put(work, fp);
6876 return err;
6877 }
regards,
dan carpenter
