for (ret = 0, i = 0; i < tb->nboot_acl; i++) {
                if (!uuid_is_null(&uuids[i]))
-                       ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%pUb",
-                                       &uuids[i]);
+                       ret += sysfs_emit_at(buf, ret, "%pUb", &uuids[i]);
 
-               ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s",
-                              i < tb->nboot_acl - 1 ? "," : "\n");
+               ret += sysfs_emit_at(buf, ret, "%s", i < tb->nboot_acl - 1 ? "," : "\n");
        }
 
 out:
            tb->security_level == TB_SECURITY_SECURE)
                deauthorization = !!tb->cm_ops->disapprove_switch;
 
-       return sprintf(buf, "%d\n", deauthorization);
+       return sysfs_emit(buf, "%d\n", deauthorization);
 }
 static DEVICE_ATTR_RO(deauthorization);
 
        if (tb->security_level < ARRAY_SIZE(tb_security_names))
                name = tb_security_names[tb->security_level];
 
-       return sprintf(buf, "%s\n", name);
+       return sysfs_emit(buf, "%s\n", name);
 }
 static DEVICE_ATTR_RO(security);
 
 
 {
        struct tb_retimer *rt = tb_to_retimer(dev);
 
-       return sprintf(buf, "%#x\n", rt->device);
+       return sysfs_emit(buf, "%#x\n", rt->device);
 }
 static DEVICE_ATTR_RO(device);
 
        else if (rt->no_nvm_upgrade)
                ret = -EOPNOTSUPP;
        else
-               ret = sprintf(buf, "%#x\n", rt->auth_status);
+               ret = sysfs_emit(buf, "%#x\n", rt->auth_status);
 
        mutex_unlock(&rt->tb->lock);
 
        if (!rt->nvm)
                ret = -EAGAIN;
        else
-               ret = sprintf(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
+               ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
 
        mutex_unlock(&rt->tb->lock);
        return ret;
 {
        struct tb_retimer *rt = tb_to_retimer(dev);
 
-       return sprintf(buf, "%#x\n", rt->vendor);
+       return sysfs_emit(buf, "%#x\n", rt->vendor);
 }
 static DEVICE_ATTR_RO(vendor);
 
 
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%u\n", sw->authorized);
+       return sysfs_emit(buf, "%u\n", sw->authorized);
 }
 
 static int disapprove_switch(struct device *dev, void *not_used)
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%u\n", sw->boot);
+       return sysfs_emit(buf, "%u\n", sw->boot);
 }
 static DEVICE_ATTR_RO(boot);
 
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%#x\n", sw->device);
+       return sysfs_emit(buf, "%#x\n", sw->device);
 }
 static DEVICE_ATTR_RO(device);
 
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%s\n", sw->device_name ? sw->device_name : "");
+       return sysfs_emit(buf, "%s\n", sw->device_name ?: "");
 }
 static DEVICE_ATTR_RO(device_name);
 
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%u\n", sw->generation);
+       return sysfs_emit(buf, "%u\n", sw->generation);
 }
 static DEVICE_ATTR_RO(generation);
 
                return restart_syscall();
 
        if (sw->key)
-               ret = sprintf(buf, "%*phN\n", TB_SWITCH_KEY_SIZE, sw->key);
+               ret = sysfs_emit(buf, "%*phN\n", TB_SWITCH_KEY_SIZE, sw->key);
        else
-               ret = sprintf(buf, "\n");
+               ret = sysfs_emit(buf, "\n");
 
        mutex_unlock(&sw->tb->lock);
        return ret;
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%u.0 Gb/s\n", sw->link_speed);
+       return sysfs_emit(buf, "%u.0 Gb/s\n", sw->link_speed);
 }
 
 /*
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%u\n", sw->link_width);
+       return sysfs_emit(buf, "%u\n", sw->link_width);
 }
 
 /*
        u32 status;
 
        nvm_get_auth_status(sw, &status);
-       return sprintf(buf, "%#x\n", status);
+       return sysfs_emit(buf, "%#x\n", status);
 }
 
 static ssize_t nvm_authenticate_sysfs(struct device *dev, const char *buf,
        else if (!sw->nvm)
                ret = -EAGAIN;
        else
-               ret = sprintf(buf, "%x.%x\n", sw->nvm->major, sw->nvm->minor);
+               ret = sysfs_emit(buf, "%x.%x\n", sw->nvm->major, sw->nvm->minor);
 
        mutex_unlock(&sw->tb->lock);
 
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%#x\n", sw->vendor);
+       return sysfs_emit(buf, "%#x\n", sw->vendor);
 }
 static DEVICE_ATTR_RO(vendor);
 
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%s\n", sw->vendor_name ? sw->vendor_name : "");
+       return sysfs_emit(buf, "%s\n", sw->vendor_name ?: "");
 }
 static DEVICE_ATTR_RO(vendor_name);
 
 {
        struct tb_switch *sw = tb_to_switch(dev);
 
-       return sprintf(buf, "%pUb\n", sw->uuid);
+       return sysfs_emit(buf, "%pUb\n", sw->uuid);
 }
 static DEVICE_ATTR_RO(unique_id);
 
 
         * It should be null terminated but anything else is pretty much
         * allowed.
         */
-       return sprintf(buf, "%*pE\n", (int)strlen(svc->key), svc->key);
+       return sysfs_emit(buf, "%*pE\n", (int)strlen(svc->key), svc->key);
 }
 static DEVICE_ATTR_RO(key);
 
 {
        struct tb_service *svc = container_of(dev, struct tb_service, dev);
 
-       return sprintf(buf, "%u\n", svc->prtcid);
+       return sysfs_emit(buf, "%u\n", svc->prtcid);
 }
 static DEVICE_ATTR_RO(prtcid);
 
 {
        struct tb_service *svc = container_of(dev, struct tb_service, dev);
 
-       return sprintf(buf, "%u\n", svc->prtcvers);
+       return sysfs_emit(buf, "%u\n", svc->prtcvers);
 }
 static DEVICE_ATTR_RO(prtcvers);
 
 {
        struct tb_service *svc = container_of(dev, struct tb_service, dev);
 
-       return sprintf(buf, "%u\n", svc->prtcrevs);
+       return sysfs_emit(buf, "%u\n", svc->prtcrevs);
 }
 static DEVICE_ATTR_RO(prtcrevs);
 
 {
        struct tb_service *svc = container_of(dev, struct tb_service, dev);
 
-       return sprintf(buf, "0x%08x\n", svc->prtcstns);
+       return sysfs_emit(buf, "0x%08x\n", svc->prtcstns);
 }
 static DEVICE_ATTR_RO(prtcstns);
 
 {
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
 
-       return sprintf(buf, "%#x\n", xd->device);
+       return sysfs_emit(buf, "%#x\n", xd->device);
 }
 static DEVICE_ATTR_RO(device);
 
 
        if (mutex_lock_interruptible(&xd->lock))
                return -ERESTARTSYS;
-       ret = sprintf(buf, "%s\n", xd->device_name ? xd->device_name : "");
+       ret = sysfs_emit(buf, "%s\n", xd->device_name ?: "");
        mutex_unlock(&xd->lock);
 
        return ret;
 {
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
 
-       return sprintf(buf, "%d\n", xd->remote_max_hopid);
+       return sysfs_emit(buf, "%d\n", xd->remote_max_hopid);
 }
 static DEVICE_ATTR_RO(maxhopid);
 
 {
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
 
-       return sprintf(buf, "%#x\n", xd->vendor);
+       return sysfs_emit(buf, "%#x\n", xd->vendor);
 }
 static DEVICE_ATTR_RO(vendor);
 
 
        if (mutex_lock_interruptible(&xd->lock))
                return -ERESTARTSYS;
-       ret = sprintf(buf, "%s\n", xd->vendor_name ? xd->vendor_name : "");
+       ret = sysfs_emit(buf, "%s\n", xd->vendor_name ?: "");
        mutex_unlock(&xd->lock);
 
        return ret;
 {
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
 
-       return sprintf(buf, "%pUb\n", xd->remote_uuid);
+       return sysfs_emit(buf, "%pUb\n", xd->remote_uuid);
 }
 static DEVICE_ATTR_RO(unique_id);
 
 {
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
 
-       return sprintf(buf, "%u.0 Gb/s\n", xd->link_speed);
+       return sysfs_emit(buf, "%u.0 Gb/s\n", xd->link_speed);
 }
 
 static DEVICE_ATTR(rx_speed, 0444, speed_show, NULL);
 {
        struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
 
-       return sprintf(buf, "%u\n", xd->link_width);
+       return sysfs_emit(buf, "%u\n", xd->link_width);
 }
 
 static DEVICE_ATTR(rx_lanes, 0444, lanes_show, NULL);